Postman

Postman is a toolchain for API developers to share, test, document and monitor APIs.

1674577278

Postman Data Driven Testing with CSV Data File

Data-driven testing is a powerful technique for automating the testing process with Postman. By using a CSV data file, you can run the same test multiple times on different datasets, saving time and reducing the amount of code needed. In this tutorial, I will show you how to import a CSV file into Postman and use it for data-driven testing.

https://youtu.be/Hwmdq1fpbUA

#postman #api #testing #automation

Postman Data Driven Testing with CSV Data File

Edward Jackson

1670653518

Learn Postman API Testing for Beginners

In this tutorial, you'll learn about manual and automated API testing with Postman. The path of API testing using Postman for beginners

API testing is a very contradictory topic. And it happens that you worked for years as a Manual tester and never faced the APIs or had a need to test those. But it can change at any moment.

Let's imagine the scenario. You passed an interview at a new company. You are a good person and they are good people. They liked you and they liked you. Even more, they offered good money.

During the interview, they said that the project is very cool and that you already know everything to start work. That the project has excellent documentation and a cool team, and all SCRUM processes are perfectly implied.

Two weeks have passed. And it's your first working day at your new job. You receive a letter from the manager. He congratulated you and says that you were expected and advertised a lot. That you are a testing expert. And in the email, he sends the user story. He says that she should be tested tomorrow. But since you are an expert, it will not cause difficulties.

You are the expert. That is true. So you check the story.

And you do not understand a single word there. In the story, a lot of things have been mentioned some endpoints, base URLs, JSON body, HTTP response code, and CURL. And all of this is new to you. You have never worked on the API level. But do you need to finish testing by tomorrow? What are you going to do?

You are the expert!
You will test the story with the help of this course!
Even more, you will have time for a cup of coffee!

What you’ll learn

Detailed understanding of REST, REST architectural constraints, client-server architecture and HTTP request-response pair
Basic knowledge about RESTful APIs and JSON
Introduction to the manual API testing
Introduction to the Postman Automated API Testing

Are there any course requirements or prerequisites?

No prior specialized knowledge is required
No programming experience needed
Desire to learn APIs
Thirst for knowledge

Who this course is for:

Manual testers who need to learn how to test APIs ASAP
People who can't imagine their life without REST APIs
People who love coffee

#postman #testing

Alex O'Sullivan

1665372648

API Testing Tutorial for Beginners

Learn about API Testing in this tutorial for beginners. Introduction to API Testing. API Testing Strategy. Postman. Test Automation

API testing is a type of software testing that analyzes an application program interface (API) to verify it fulfills its expected functionality, security, performance, and reliability.

We have many advantages for learning API Testing, some of them are:

Improved test coverage
Greater test stability
Reduced testing costs

API test automation requires less code than automated GUI tests, resulting in faster testing and a lower overall cost.

Through this course; the audience would get a detailed insight into how to test APIs. In this course, all information is presented in an easy straightforward way so any non-tech person can start with it to have the proper guidance about API testing, also any software engineer who is looking to enrich his/her knowledge related to API Testing is the right course for you.

What you’ll learn

API Testing Strategy
Postman
Test Automation
API

Are there any course requirements or prerequisites?

Software Testing Knowledge

Who this course is for:

Beginner QAs

#api #testing #softwaretesting #postman

Zachary Palmer

1664954189

API Testing using Postman

In this tutorial, you will learn how to do simple API Testing using Postman. Get started testing API by yourself using Postman

API testing is a very contradictory topic. And it happens that you worked for years as the Manual tester and never faced the APIs or had a need to test those. But it can change at any moment.

Let's imagine the scenario. You passed an interview at a new company. You are a good person and they are good people. They liked you and they liked you. Even more, they offered good money.

During the interview, they said that the project is very cool and that you already know everything to start work. That the project has excellent documentation, a cool team, and all SCRUM processes are perfectly implied.

Two weeks have passed. And it's your first working day at your new job. You receive a letter from the manager. He congratulates you and says that you were expected and advertised a lot. That you are a testing expert. And in the email, he sends the user story. He says that she should be tested for tomorrow. But since you are an expert, it will not cause difficulties.

You are the expert. That is true. So you check the story.

And you do not understand a single word there. In the story, a lot of things have been mentioned some endpoint, base URLs, JSON body, HTTP response code, and CURL. And all of this is new to you. You have never worked on the API level. But do you need to finish testing by tomorrow? What you are going to do?

You are the expert!

You will test the story with the help of this course!

Even more, you will have time for a cup of coffee!

What you’ll learn

Ready to perform Manual & Automation testing of the API using Postman
Use Postman to automate various parts of the API Testing process
Detailed understanding of REST, REST architectural constraints, client-server architecture and HTTP request-response pair
Testing of the POST, GET, PUT, DELETE requests
Basic knowledge about RESTful APIs and JSON

Are there any course requirements or prerequisites?

No prior specialized knowledge is required
No programming experience needed
Desire to learn APIs
Thirst for knowledge
Loving coffee

Who this course is for:

Manual testers who need to learn how to test APIs ASAP, manual test engineers, , people who can't imagine their life without REST APIs, people who love coffee

#postman #api #testing

Minh Nguyet

1659961080

Cách Kiểm Tra Và Gỡ Lỗi Yêu Cầu GRPC Của Bạn Trong Postman

Chúng tôi có thể sử dụng Postman cho các yêu cầu gRPC. (Trong khi viết bài này, nó đang ở giai đoạn BETA.)

Trong bài viết này, chúng tôi sẽ sử dụng công cụ Postman (như một ứng dụng khách gRPC) để kiểm tra API gRPC của chúng tôi. Tôi sẽ sử dụng một máy chủ gRPC đơn giản mà tôi đã phát triển khi viết bài này .

Bạn sẽ có thể kiểm tra bất kỳ phương pháp máy chủ gRPC nào ở cuối bài viết này.

Khởi động máy chủ gRPC

Tổng quan cấp cao về Máy chủ của chúng tôi

Máy chủ gRPC của chúng tôi có

2 loại tin nhắn

SimpleRequest
SimpleResponse

1 dịch vụ

SimpleService

4 RPC trong Dịch vụ đó

RPCRequest - RPC một bậc
ServerStreaming - Server Streaming RPC
ClientStreaming - Client Streaming RPC
Phát trực tuyếnBiDirectional - RPC phát trực tuyến hai chiều

Tệp Proto

syntax = "proto3";

option go_package = "simple/testgrpc";

message SimpleRequest{
    string request_need = 1;
}

message SimpleResponse{
    string response = 1;
}

service SimpleService{
    // unary RPC
    rpc RPCRequest(SimpleRequest) returns (SimpleResponse);
    // Server Streaming
    rpc ServerStreaming(SimpleRequest) returns (stream SimpleResponse);
    // Client Streaming
    rpc ClientStreaming(stream SimpleRequest) returns (SimpleResponse);
    // Bi-Directional Streaming
    rpc StreamingBiDirectional(stream SimpleRequest) returns (stream SimpleResponse);
}

Tôi đã khởi động máy chủ gRPC của chúng tôi đang nghe tại localhost: 8090

Postman gRPC Client

Mở Người đưa thư. Nhấp vào Mới .
Chọn yêu cầu gRPC
Cửa sổ yêu cầu sẽ được mở
Nhập URL máy chủ. (Máy chủ của chúng tôi không yêu cầu TLS nên chúng tôi không chọn nó.)
Bây giờ chúng ta phải Chọn một phương thức để gọi. Đối với người đưa thư đó nên biết về máy chủ gRPC của chúng tôi. Chúng tôi có thể làm cho Người đưa thư biết về máy chủ của chúng tôi theo 3 cách,

- bằng cách nhập tệp proto

- sử dụng phản chiếu máy chủ (đối với điều này Máy chủ của chúng tôi cần có phản chiếu máy chủ như một tiện ích mở rộng tùy chọn để hỗ trợ khách hàng trong việc xây dựng thời gian chạy các yêu cầu mà không cần thông tin sơ khai được biên dịch trước vào máy khách.)

- bằng cách sử dụng các API Protobuf được tạo trong không gian làm việc Postman. (ngoài ra, bạn có thể nhập tệp proto và sau đó tạo API với proto đã nhập.)

Chúng tôi sẽ đi với tùy chọn đầu tiên và sau đó tạo API. (Việc tạo API sẽ do Người đưa thư đảm nhận sau khi bạn nhập tệp proto)

Nhấp vào Tiếp theo . Postman yêu cầu chúng tôi nhập tệp proto của chúng tôi dưới dạng API để sử dụng lại.
Cung cấp tên API và tên Phiên bản . (Nếu bạn không có, hãy tạo nó bằng cách nhập tên bạn muốn Postman sẽ yêu cầu tạo)

Nhấp vào Nhập dưới dạng API .

Bây giờ, chúng tôi đã sẵn sàng với định nghĩa Máy chủ của mình trong Người đưa thư bằng cách nhập tệp proto của chúng tôi.

Bây giờ hãy nhấp vào Chọn một phương pháp để chọn phương thức gRPC của chúng tôi để gọi.

Tại thời điểm này Postman biết về Máy chủ của chúng tôi, vì vậy các RPC được xác định trong máy chủ của chúng tôi sẽ có sẵn trong menu thả xuống.

Trong khi gửi yêu cầu, bạn có thể ủy quyền yêu cầu với sự trợ giúp của tiện ích con Ủy quyền nếu cần. Ngoài ra, bạn có thể gửi một số Siêu dữ liệu nếu cần.

Yêu cầu đơn nguyên

Chọn một phương pháp

Chọn phương thức RPCRequest phương thức là RPC đơn nhất của Máy chủ của chúng tôi và chỉ cần nhấp vào nút Gọi, để gọi RPC và chúng tôi đã nhận được phản hồi của mình.

yêu cầu trống với phản hồi

Postman biết về Máy chủ của chúng tôi vì vậy, nó có tính năng Tạo Thông báo Ví dụ .

Nhấp vào Tạo Thông báo Sơ đồ ở cuối Tiện ích Thông báo và gọi RPC.

Tạo tin nhắn và nhận phản hồi

Ái chà! chúng tôi đã nhận được phản hồi của chúng tôi.

Phát trực tuyến khách hàng

Bây giờ, chúng ta sẽ thử Client Streaming RPC trong Postman.

Sau khi bạn chọn phương pháp phát trực tuyến Khách hàng trong Chọn phương thức, sau đó Người đưa thư sẽ mở một tiện ích để gửi luồng yêu cầu của chúng tôi.

Dòng

Bây giờ hãy nhấp vào Tạo tin nhắn mẫu để tạo tin nhắn hoặc soạn tin nhắn và bấm vào Gửi .

gửi tin nhắn luồng

Lặp lại bước này bao nhiêu lần bạn muốn. Vì nó là một RPC phát trực tuyến Máy khách. Sau khi bạn hoàn tất luồng tin nhắn của mình, hãy nhấp vào Kết thúc phát trực tuyến.

Và Bạn sẽ nhận được phản hồi.

Phản hồi phát trực tuyến của khách hàng

Chúng tôi đã nhận được phản hồi của mình.

Máy chủ truyền trực tuyến

Bây giờ chọn phương thức ServerStreaming và gọi RPC cùng với thông báo của chúng tôi, Chúng tôi sẽ nhận được phản hồi từ luồng của chúng tôi.

Máy chủ truyền trực tuyến

Chúng tôi đã nhận được phản hồi của Luồng.

Phát trực tuyến hai chiều

Chọn phương pháp StreamingBiDirectional và gọi RPC để kiểm tra tính năng phát trực tuyến Hai chiều.

Sau khi tôi gửi yêu cầu, tôi đã nhận được phản hồi cho yêu cầu đó (Đó là cách Máy chủ được triển khai)

gửi và nhận

Sau khi gửi yêu cầu và nhận được phản hồi, hãy kết thúc luồng.

Phát trực tuyến hai hướng

Bạn có thể lưu các yêu cầu trong Bộ sưu tập của Người đưa thư như bình thường.

API

API mà chúng tôi đã tạo bằng cách nhập tệp proto của chúng tôi có thể được sử dụng lại

Bản tóm tắt

Bây giờ bạn đã biết cách sử dụng Người đưa thư làm Ứng dụng khách gRPC .

Liên kết: https://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4

#postman #grpc #go

Cách Kiểm Tra Và Gỡ Lỗi Yêu Cầu GRPC Của Bạn Trong Postman

Молчанова Рената Алексеевна

1659953836

Как протестировать и отладить ваш запрос GRPC в Postman

Мы можем использовать Postman для запросов gRPC. (Во время написания этой статьи она находится на стадии БЕТА.)

В этой статье мы собираемся использовать инструмент Postman (в качестве клиента gRPC) для тестирования нашего API gRPC. Я собираюсь использовать простой сервер gRPC, который я разработал во время написания этой статьи .

В конце этой статьи вы сможете протестировать любые методы gRPC Server.

Запустите сервер gRPC

Общий обзор нашего сервера

Наш сервер gRPC имеет

2 типа сообщений

Простой запрос
Простой ответ

1 услуга

ПростСервис

4 RPC в этой службе

RPCRequest — Унарный RPC
ServerStreaming — серверная потоковая передача RPC
ClientStreaming — клиентская потоковая передача RPC
StreamingBiDirectional — двунаправленный потоковый RPC

Прото файл

syntax = "proto3";

option go_package = "simple/testgrpc";

message SimpleRequest{
    string request_need = 1;
}

message SimpleResponse{
    string response = 1;
}

service SimpleService{
    // unary RPC
    rpc RPCRequest(SimpleRequest) returns (SimpleResponse);
    // Server Streaming
    rpc ServerStreaming(SimpleRequest) returns (stream SimpleResponse);
    // Client Streaming
    rpc ClientStreaming(stream SimpleRequest) returns (SimpleResponse);
    // Bi-Directional Streaming
    rpc StreamingBiDirectional(stream SimpleRequest) returns (stream SimpleResponse);
}

Я запустил наш сервер gRPC, который прослушивает localhost:8090.

Почтальон gRPC-клиент

Откройте Почтальона. Щелкните Создать .
Выберите запрос gRPC
Откроется окно запроса
Введите URL-адрес сервера. (Наш сервер не требует TLS, поэтому мы его не выбираем.)
Теперь нам нужно выбрать метод для вызова. Для этого Почтальон должен знать о нашем сервере gRPC. Мы можем заставить Почтальона узнать о нашем сервере тремя способами:

— путем импорта прото-файла

— использование отражения сервера (для этого наш Сервер должен иметь отражение сервера в качестве дополнительного расширения, чтобы помочь клиентам в построении запросов во время выполнения без предварительной компиляции информации-заглушки в клиенте.)

— с помощью API-интерфейсов Protobuf, созданных в рабочей области Postman. (также вы можете импортировать файл прототипа, а затем создать API с импортированным прототипом.)

Мы выберем 1-й вариант, а затем создадим API. (Создание API будет выполнено почтальоном после того, как вы импортируете прото-файл)

Нажмите «Далее» . Почтальон просит нас импортировать наш прото-файл как API для повторного использования.
Укажите имя API и имя версии . (Если у вас его нет, создайте его, введя имя, которое вы хотите, чтобы Postman попросил создать)

Нажмите «Импортировать как API » .

Теперь мы готовы с нашим определением сервера в почтальоне, импортировав наш прото-файл.

Теперь нажмите « Выбрать метод », чтобы выбрать наш метод gRPC для вызова.

На данный момент Почтальон знает о нашем сервере, поэтому RPC, определенные на нашем сервере, будут доступны в раскрывающемся списке.

При отправке запроса вы можете авторизовать запрос с помощью виджета Авторизация , если это необходимо. Также вы можете отправить некоторые метаданные , если это необходимо.

Унарный запрос

Выберите метод

Выберите метод RPCRequest , который является унарным RPC нашего сервера, и просто нажмите кнопку Invoke, чтобы вызвать RPC, и мы получили наш ответ.

пустой запрос с ответом

Почтальон знает о нашем сервере, поэтому у него есть возможность генерировать пример сообщения .

Нажмите « Создать сообщение Exmaple» в нижней части виджета сообщений и вызовите RPC.

Генерация сообщений и получение ответа

Вау! мы получили свой ответ.

Клиентская потоковая передача

Теперь мы попробуем Client Streaming RPC в Postman.

После того, как вы выберете метод потоковой передачи клиента в разделе « Выбрать метод», Postman откроет виджет для отправки нашего потока запросов.

Ручей

Теперь нажмите « Создать пример сообщения » , чтобы сгенерировать сообщение или составить сообщение, и нажмите « Отправить » .

отправить потоковое сообщение

Повторите этот шаг столько раз, сколько хотите. Так как это клиентский потоковый RPC. Когда вы закончите с потоком сообщений, нажмите « Завершить потоковую передачу».

И Вы получите ответ обратно.

Ответ клиента на потоковую передачу

Мы получили наш ответ.

Потоковая передача сервера

Теперь выберите метод ServerStreaming и вызовите RPC с нашим сообщением. Мы получим наши потоковые ответы.

Потоковая передача сервера

Мы получили ответы Stream.

Двунаправленная потоковая передача

Выберите метод StreamingBiDirectional и вызовите RPC для проверки двунаправленной потоковой передачи.

Как только я отправил запрос, я получил ответ на этот запрос (так реализован сервер)

отправлять и получать

После отправки запроса и получения ответа завершите поток.

Двунаправленная потоковая передача

Вы можете сохранять запросы в коллекции Postman , как обычно.

API

API, который мы создали, импортировав наш прото-файл, можно использовать повторно.

Резюме

Теперь вы знаете, как использовать Postman в качестве клиента gRPC .

Ссылка: https://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4

#postman #grpc #go

Как протестировать и отладить ваш запрос GRPC в Postman

山田千代

1659946588

如何在 Postman 中測試和調試 GRPC 請求

我們可以將 Postman 用於 gRPC 請求。（在撰寫本文時，它處於 BETA 階段。）

在本文中，我們將使用 Postman 工具（作為 gRPC 客戶端）來測試我們的 gRPC API。我將使用我在撰寫本文時開發的簡單 gRPC 服務器。

您應該能夠在本文結尾處測試任何 gRPC 服務器方法。

啟動 gRPC 服務器

我們的服務器的高級概述

我們的 gRPC 服務器有

2 消息類型

簡單請求
簡單響應

1 服務

簡單服務

該服務中的 4 個 RPC

RPCRequest — 一元 RPC
ServerStreaming — 服務器流式傳輸 RPC
ClientStreaming — 客戶端流 RPC
StreamingBiDirectional — 雙向流 RPC

原型文件

syntax = "proto3";

option go_package = "simple/testgrpc";

message SimpleRequest{
    string request_need = 1;
}

message SimpleResponse{
    string response = 1;
}

service SimpleService{
    // unary RPC
    rpc RPCRequest(SimpleRequest) returns (SimpleResponse);
    // Server Streaming
    rpc ServerStreaming(SimpleRequest) returns (stream SimpleResponse);
    // Client Streaming
    rpc ClientStreaming(stream SimpleRequest) returns (SimpleResponse);
    // Bi-Directional Streaming
    rpc StreamingBiDirectional(stream SimpleRequest) returns (stream SimpleResponse);
}

我已經啟動了我們的 gRPC 服務器，它正在監聽localhost:8090

郵遞員 gRPC 客戶端

打開郵遞員。單擊新建。
選擇gRPC 請求
申請窗口將打開
輸入服務器 URL。（我們的服務器不需要 TLS，所以我們沒有選擇它。）
現在我們必須選擇一個方法來調用。因為那個 Postman 應該知道我們的 gRPC 服務器。我們可以通過 3 種方式讓 Postman 了解我們的服務器，

— 通過導入 proto 文件

— 使用服務器反射（為此，我們的服務器需要將服務器反射作為可選擴展來幫助客戶端在運行時構建請求，而無需將存根信息預編譯到客戶端中。）

— 通過使用在 Postman 工作區中創建的 Protobuf API。（您也可以導入 proto 文件，然後使用導入的 proto 創建 API。）

我們將使用第一個選項，然後創建 API。（導入 proto 文件後，API 創建將由 Postman 負責）

單擊下一步。Postman 要求我們將 proto 文件作為 API 導入以進行重用。
給出API 名稱和版本名稱。（如果您沒有創建它，請輸入您希望 Postman 要求創建的名稱）

單擊導入為 API。

現在，通過導入我們的 proto 文件，我們已準備好在 Postman 中定義服務器。

現在單擊Select a method以選擇我們要調用的 gRPC 方法。

此時 Postman 知道我們的服務器，因此我們服務器中定義的 RPC 將在下拉列表中可用。

在發送請求時，如果需要，您可以在授權小部件的幫助下授權請求。如果需要，您也可以發送一些元數據。

一元請求

選擇一種方法

選擇方法RPCRequest方法，它是我們服務器的一元 RPC，然後單擊 Invoke 按鈕，調用 RPC，我們得到了響應。

帶有響應的空請求

Postman 知道我們的服務器，所以它具有生成示例消息的功能。

單擊Message Widget 底部的Generate Exmaple Message並調用 RPC。

生成消息並獲得響應

哇！我們得到了回應。

客戶端流式傳輸

現在，我們將在 Postman 中嘗試 Client Streaming RPC。

在選擇方法中選擇客戶端流方法後， Postman 會打開一個小部件來發送我們的請求流。

溪流

現在單擊生成示例消息以生成消息或撰寫消息，然後單擊發送。

發送流消息

重複此步驟多次。因為它是一個客戶端流式 RPC。完成消息流後，單擊結束流式傳輸。

你會得到回复。

客戶端流式響應

我們得到了回應。

服務器流式傳輸

現在選擇ServerStreaming方法並使用我們的消息調用 RPC，我們將獲得我們的流響應。

服務器流式傳輸

我們得到了 Stream 響應。

雙向流

選擇StreamingBiDirectional方法並調用 RPC 來測試雙向流。

發送請求後，我得到了該請求的響應（這就是服務器的實現方式）

發送和接收

發送請求並收到響應後，結束流。

雙向流

您可以像往常一樣將請求保存在Postman Collections中。

API

我們通過導入 proto 文件創建的 API 可以重複使用

概括

現在您已經了解瞭如何將 Postman 用作gRPC 客戶端。

鏈接：https ://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4

#postman #grpc #go

Thierry Perret

1659939360

Comment Tester Et Déboguer Votre Demande GRPC Dans Postman

Nous pouvons utiliser le Postman pour les requêtes gRPC. (Lors de la rédaction de cet article, il est en phase BETA.)

Dans cet article, nous allons utiliser l'outil Postman (en tant que client gRPC) pour tester notre API gRPC. Je vais utiliser un simple serveur gRPC que j'ai développé lors de la rédaction de cet article .

Vous devriez pouvoir tester toutes les méthodes du serveur gRPC à la fin de cet article.

Démarrer le serveur gRPC

Aperçu de haut niveau de notre serveur

Notre serveur gRPC a

2 types de messages

SimpleRequête
SimpleReponse

1 Prestation

SimpleService

4 RPC dans ce service

RPCRequest — RPC unaire
ServerStreaming — Serveur Streaming RPC
ClientStreaming — Client Streaming RPC
StreamingBiDirectional — RPC de streaming bidirectionnel

Fichier prototype

syntax = "proto3";

option go_package = "simple/testgrpc";

message SimpleRequest{
    string request_need = 1;
}

message SimpleResponse{
    string response = 1;
}

service SimpleService{
    // unary RPC
    rpc RPCRequest(SimpleRequest) returns (SimpleResponse);
    // Server Streaming
    rpc ServerStreaming(SimpleRequest) returns (stream SimpleResponse);
    // Client Streaming
    rpc ClientStreaming(stream SimpleRequest) returns (SimpleResponse);
    // Bi-Directional Streaming
    rpc StreamingBiDirectional(stream SimpleRequest) returns (stream SimpleResponse);
}

J'ai démarré notre serveur gRPC qui écoute sur localhost:8090

Client gRPC du facteur

Ouvrez le facteur. Cliquez sur Nouveau .
Sélectionner la requête gRPC
La fenêtre de demande s'ouvrira
Saisissez l'URL du serveur. (Notre serveur ne nécessite pas TLS, nous ne le sélectionnons donc pas.)
Maintenant, nous devons sélectionner une méthode à appeler. Pour cela, Postman devrait connaître notre serveur gRPC. Nous pouvons faire en sorte que Postman connaisse notre serveur de 3 façons,

— en important le fichier proto

- en utilisant la réflexion du serveur (pour cela, notre serveur doit avoir la réflexion du serveur en tant qu'extension facultative pour aider les clients à construire des requêtes à l'exécution sans avoir les informations de stub précompilées dans le client.)

— en utilisant les API Protobuf créées dans l'espace de travail Postman. (Vous pouvez également importer le fichier proto, puis créer l'API avec le proto importé.)

Nous allons choisir la 1ère option puis créer l'API. (La création de l'API sera prise en charge par le facteur une fois que vous aurez importé le fichier proto)

Cliquez sur Suivant . Postman nous demande d'importer notre fichier proto en tant qu'API pour le réutiliser.
Donnez le nom de l' API et le nom de la version . (Si vous n'en avez pas, créez-le en tapant le nom que vous voulez que Postman vous demande de créer)

Cliquez sur Importer en tant qu'API .

Maintenant, nous sommes prêts avec notre définition de serveur dans le facteur en important notre fichier proto.

Cliquez maintenant sur Sélectionner une méthode pour sélectionner notre méthode gRPC à appeler.

À ce stade, Postman connaît notre serveur, de sorte que les RPC définis sur notre serveur seront disponibles dans la liste déroulante.

Lors de l'envoi d'une demande, vous pouvez autoriser la demande à l'aide du widget d' autorisation si nécessaire. Vous pouvez également envoyer des métadonnées si nécessaire.

Requête unaire

Sélectionnez une méthode

Sélectionnez la méthode RPCRequest method qui est le RPC unaire de notre serveur et cliquez simplement sur le bouton Invoke, pour invoquer le RPC et nous avons obtenu notre réponse.

requête vide avec la réponse

Postman connaît notre serveur, il a donc la fonction de générer un exemple de message .

Cliquez sur Générer un exemple de message en bas du widget de message et invoquez le RPC.

Générer des messages et obtenir la réponse

Waouh ! nous avons eu notre réponse.

Diffusion client

Maintenant, nous allons essayer le Client Streaming RPC dans le Postman.

Une fois que vous avez sélectionné la méthode de streaming client dans Sélectionner une méthode, Postman ouvre un widget pour envoyer notre flux de demandes.

Flux

Cliquez maintenant sur Générer un exemple de message pour générer le message ou composez un message et cliquez sur Envoyer .

envoyer un message de flux

Répétez cette étape autant de fois que vous le souhaitez. Puisqu'il s'agit d'un RPC de streaming client. Une fois que vous avez terminé avec votre flux de messages, cliquez sur Terminer le streaming.

Et vous obtiendrez la réponse en retour.

Réponse de flux client

Nous avons eu notre réponse.

Diffusion de serveur

Sélectionnez maintenant la méthode ServerStreaming et invoquez le RPC avec notre message, nous obtiendrons nos réponses de flux.

Diffusion de serveur

Nous avons reçu les réponses du flux.

Streaming bidirectionnel

Sélectionnez la méthode StreamingBiDirectional et appelez le RPC pour tester le streaming bidirectionnel.

Une fois que j'ai envoyé la demande, j'ai reçu la réponse à cette demande (c'est ainsi que le serveur est implémenté)

envoyer et recevoir

Après avoir envoyé la demande et reçu la réponse, mettez fin au flux.

Streaming bidirectionnel

Vous pouvez enregistrer les demandes dans les collections Postman comme d'habitude.

API

L'API que nous avons créé en important notre fichier proto peut être réutilisé

Sommaire

Maintenant que vous savez comment utiliser Postman en tant que client gRPC .

Lien : https://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4

#postman #grpc #go

Comment Tester Et Déboguer Votre Demande GRPC Dans Postman

Hans Marvin

1659932042

How to Test and Debug Your GRPC Request in Postman

We can use the Postman for the gRPC requests. (While writing this article it is in the BETA stage.)

In this article, we are going to use the Postman tool(as a gRPC client) to test our gRPC API. I am going to use a simple gRPC server which I have developed while writing this article.

You should be able to test any gRPC Server methods at the end of this article.

See more at: https://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4

#postman #grpc #go

How to Test and Debug Your GRPC Request in Postman

Adolphus Tillman

1659850740

How to Automate API Tests with Postman

APIs are the driving force behind virtually every application you’ll build as a developer, serving as a channel of communication between two or more software components.

However, the consequence of this type of system is that the failure of one component can have a significant impact on the other components that depend on it. Therefore, it’s crucial to test your APIs extensively to ensure the correctness and predictability of your application.

There are many different ways you can test your APIs, and whichever method or combination of methods you choose will ultimately depend on your current business needs, available resources, and implementation details.

In this article, we’ll explore how to write automated functional and integration tests for your APIs that will run in a CI/CD pipeline.

See more at: https://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

津田あすか

1659793080

Postman で API テストを自動化する方法

API は、開発者が構築する事実上すべてのアプリケーションの原動力であり、2 つ以上のソフトウェアコンポーネント間の通信チャネルとして機能します。

ただし、このタイプのシステムの結果として、1 つのコンポーネントの障害が、それに依存する他のコンポーネントに大きな影響を与える可能性があります。したがって、API を広範囲にテストして、アプリケーションの正確性と予測可能性を確認することが重要です。

API をテストするにはさまざまな方法があります。選択する方法または方法の組み合わせは、最終的には現在のビジネスニーズ、利用可能なリソース、および実装の詳細によって異なります。

この記事では、CI/CD パイプラインで実行される API の自動化された機能テストと統合テストを作成する方法について説明します。

API テストを自動化する必要があるのはなぜですか?

テストを作成すると、いつでもアプリケーションの予測可能性と正確性を確保できます。したがって、コードベースが変更されるたびにテストを実行する必要があります。このような反復的なタスクは、多くの場合、自動化に適しています。

自動化されたテストは、導入した可能性のあるバグを指摘するために常にテストに頼ることができるため、自信を持ってアプリケーションに変更を加えたり、新しい機能を追加したりできます。

Postman を使用して API テストを作成する

Postmanは、API の構築、テスト、文書化、およびモック化のための完全なツールセットを提供するプラットフォームです。開発者として、 Postman を使用してローカルで開発しているときにバックエンドアプリケーションにリクエストを送信したことがあると思いますが、Postman を使用してさらに多くのことができます。

郵便配達員の設定

このチュートリアルを進めるには、Postman アカウントが必要です。まだお持ちでない場合は、無料のアカウントを作成してください。次に、Postman ワークスペースに移動して開始します。

という名前の新しいコレクションをDelivery-API Tests作成し、このセクションで後で作成する配信 API の機能テストと統合テストを記述します。機能テストでは、単一の API エンドポイントの動作をチェックし、要求と応答のサイクルが期待どおりであることを確認します。一方、統合テストでは、2 つ以上のエンドポイントで構成される特定のフローをチェックして、ユーザーフローに含まれるさまざまなコンポーネントが期待どおりに機能するかどうかを判断します。

この時点で、ワークスペースの左側のパネルにコレクションが表示されます。

Postman ワークスペースコレクション

リクエストの設定

次に、テストを保持するリクエストを作成する必要があります。リクエストは API エンドポイントを表します。Delivery-API Testsコレクションで、右側に表示されるメニューボタンをクリックします。

[リクエストの追加] を選択し、作成されるリクエストに名前を付けSearch Deliveriesます。Select Delivery、Confirm Pickup、という名前の 3 つの要求をさらに作成しますComplete Delivery。

次に、リクエストごとにテストを作成する必要があります。Postman には組み込みのテストツールがあり、JavaScript 構文を使用してテストを記述できます。リクエストが実行された直後にテストが実行され、テストスクリプトでリクエストから返されたレスポンスにアクセスできます。

Delivery-API Testsコレクションで、要求Search Deliveriesを選択し、[テスト] タブを選択します。次のコードブロックをエディターに貼り付けます。

const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains results", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("array")
    pm.expect(responseJson.data[0]).to.haveOwnProperty("status")
})

pm.collectionVariables.set("SELECTED_DELIVERY_ID", responseJson.data[0].id)

上記のコードでは、を呼び出して、JSON 形式で応答を取得しますpm.response.json()。pmは、すべてのリクエストスクリプトで使用できるグローバルオブジェクトであることに注意してください。次に、を使用して 2 つのテストケースを定義しpm.testました。

JavaScript でのテストに精通している場合、ここでの構文は簡単です。Postman はChai アサーションライブラリの構文をサポートしているため、JavaScript で既に行っているのと同じ方法でテストを記述できます。

テストケースでは、正しいステータスコード、返されたデータのタイプ、およびいくつかの追加の必須フィールドをチェックしています。これらは単純なテストですが、目標は Postman でのテストの概念を理解することです。

コードブロックの最後の行で、というコレクション変数を設定していることに注意してくださいSELECTED_DELIVERY_ID。コレクション変数は、リクエスト間でデータを共有する直感的な方法です。

次に、他のリクエストのテストを書きたいと思います。次のコードブロックを対応するリクエストに貼り付けます。

// Select Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("QUEUED")
})


// Confirm Pickup
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("PICKED_UP")
})


// Complete Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("COMPLETED")
})

status他のリクエストのテストケースは、フィールドでのアサーションを除いて同じです。リクエストのテストができたので、実行してみましょう。API リクエストを処理するバックエンドサーバーを作成する必要があります。バックエンドサーバーは、REST に準拠している限り、任意の言語またはフレームワークで実装できますが、この記事では、Koaを使用して単純な Node.js サーバーを構築します。

API サーバーの構築

ターミナルでフォルダーを作成し、Yarn または npm で Node.js プロジェクトを初期化します。

$ mkdir delivery-api
$ cd delivery-api
$ yarn init -y

次に、というファイルを作成しapp.js、必要な依存関係をインストールします。

$ touch app.js
$ yarn add koa @koa/router

package.jsonファイルに、次のスクリプトを追加します。

//...
  "scripts": {
    "start": "node app.js"
  },
//...

Koa は、Express に似た Node.js 用の軽量 HTTP ミドルウェアフレームワークです。Koa サーバーを初期化し、Postman で設定した要求に対応するルートハンドラーを定義しましょう。app.jsファイルに、以下のコードブロックを貼り付けます。

const Koa = require("koa");
const Router = require("@koa/router");
const app = new Koa();
const router = new Router();

app.use(router.routes());

const deliveries = [
   {
      id: "1",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148928000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148928000",
      instructions: "",
      status: "CREATED",
   },
   {
      id: "2",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148915000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148915000",
      instructions: "",
      status: "CREATED",
   },
];

router.get("/deliveries", (ctx) => {
   ctx.body = {
      status: "00",
      message: "successs",
      data: deliveries,
   };
});

router.get("/deliveries/:id/select", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "QUEUED" },
   };
});

router.get("/deliveries/:id/confirm-pickup", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "PICKED_UP" },
   };
});

router.get("/deliveries/:id/complete", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "COMPLETED" },
   };
});

app.listen(8000);

ここにはたくさんのことが起こっているので、それを分解しましょう。まず、新しい Koa アプリと新しいRouterオブジェクトを初期化します。このrouterインスタンスを使用して、Postman で作成したリクエストに一致するパスを持つ 4 つのルートを定義します。最後に、を呼び出してサーバーを起動しますapp.listen()。

要約すると、この単純な API サーバーは、食品配達アプリの注文を配達するプロセスをシミュレートしようとしています。次に、ターミナルで実行してサーバーを起動yarn startします。

Postman での手動テストの実行

これで、テストを実行するためのすべての設定が完了しました。Web で Postman を使用している場合は、に接続できませんlocalhost。ただし、これを回避するには 2 つの方法があります。Postman デスクトップアプリをダウンロードするか、ngrokをトンネルとして使用してlocalhostポートをインターネットに公開することができます。

ngrok を使用することに決めた場合は、それをインストールして、サーバーを指すトンネルを開始するだけです。別のターミナルインスタンスを開き、次のコマンドを実行して、表示された URL をコピーします。

$ ngrok http 8000

URL はのようになりますhttps://3d43-154-130-109-210.ngrok.io。Web またはデスクトップで Postman に移動し、コレクションを選択して変数タブDelivery-API Testsを開きます。

API_BASE_URLPostman デスクトップを使用していない場合は、キーを含む変数を追加し、値をhttp://localhost:8000ngrok URL に設定します。新しい変数を追加するときは、必ず [ Persist All ] をクリックして、外部サービスがアクセスできるようにしてください。

Postman 変数配信 API テスト

これで、リクエストごとにコレクション変数を使用できるようになりました。各リクエストの URL フィールドを次の値に更新します。

Search Deliveries:{{API_BASE_URL}}/deliveries?page=1&count=20
Select Delivery:{{API_BASE_URL}}/deliveries/:id/select
Confirm Pickup:{{API_BASE_URL}}/deliveries/:id/confirm-pickup
Complete Delivery:{{API_BASE_URL}}/deliveries/:id/complete

2 つの方法のいずれかを使用して、テストを手動で実行できます。1 つ目は、リクエストを個別に実行して、各リクエストのテストスクリプトを実行できるようにすることです。または、コレクションランナーを使用してコレクションを一度に実行することもできます。次のセクションではコレクションランナーを使用しますが、[送信] ボタンをクリックして、一時的に各リクエストを手動で実行できます。

リクエストを実行すると、下部パネルに応答が表示されますが、下部パネルの [テスト結果] タブをクリックしてテスト結果を確認することもできます。

Postman テスト結果タブ

Postman でテストを実行するために必要なことはこれだけです。ただし、コードベースに変更を加えるたびに Postman ワークスペースにアクセスしてテストを実行するのは直感的ではありません。このアプローチは開発ワークフローと一致しないため、改善しましょう。

API テストの自動化

このセクションでは、ワークフローを自動化することで、テストプロセスをより直感的にし、時間を節約します。最適化された開発ワークフローには、ローカルで変更を加え、新しい機能をソース管理にプッシュすることが含まれます。これらの機能は CI/CD パイプラインによって取得され、ビルドまたはデプロイタスクがトリガーされます。

Postman には、CLI からコレクションを実行できるNewman というコマンドラインツールが用意されています。また、CI/CD 環境とのシームレスな統合も提供します。つまり、展開ステップ中に実行するテストをセットアップできます。これにより、テストプロセスが大幅に簡素化され、ワークスペースで常にテストを実行する必要がなくなります。

Newman と GitHub Actions の統合

多くの継続的インテグレーションサービスで Newman をセットアップできます。この記事では、GitHub Actions を使用します。Newman のワークフローを定義することから始めましょう。delivery-apiプロジェクトで、次のコマンドを実行します。

$ mkdir .github
$ mkdir .github/workflows
$ touch .github/workflows/postman-tests.yml

postman-tests.yml次のワークフロー定義をファイルに追加します。

# postman-tests.yml
name: Newman Run
on:
  push:
    branches:
      - main
  # types: [closed]
jobs:
  newman:
    name: Postman-tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Node
        uses: actions/setup-node@v3
        with:
          node-version: 14
      - name: Install Newman & Reporter
        run: |
          npm install -g newman
          npm install -g newman-reporter-htmlextra
      # Make directory for test results in workspace
      - name: Make Directory
        run: mkdir -p newman-results
      # Run newman cli
      - name: Run Newman
        env:
          POSTMAN_API_URL: 'https://api.getpostman.com'
          POSTMAN_API_KEY: ${{ secrets.POSTMAN_API_KEY }}
          POSTMAN_COLLECTION_UID: ${{ secrets.POSTMAN_COLLECTION_UID }}
        run: |
          newman run "${{env.POSTMAN_API_URL}}/collections/${{env.POSTMAN_COLLECTION_UID}}?apikey=${{env.POSTMAN_API_KEY}}" \
          -r htmlextra,cli --reporter-htmlextra-export newman-results/htmlreport.html
      # Upload test results to workspace
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: Postman_Test_Reports
          path: newman-results

上記のコードは、リポジトリ、特にデフォルトmainブランチにプッシュするときに実行される単純なワークフローです。一連のステップで Postman テストのジョブを定義します。

まず、チェックアウトアクションを実行してから、事前定義されたアクションを使用して Node.js をインストールしactions/setup-node@v3ます。次に、Newman とをインストールしnewman-reporter-htmlextraます。レポーターは、テストの要約を HTML 形式で生成する Newman のプラグインです。次に、コレクションの Postman API URL など、いくつかの引数を指定して Newman CLI ツールを実行します。

いくつかの環境変数を定義したことに注意してください。POSTMAN_API_KEYとはPOSTMAN_COLLECTION_UID、GitHub アクションシークレットから取得されています。これらのシークレットを設定する前に、リポジトリを作成する必要があります。最後に、Newman を実行した後、事前定義されたアクションactions/upload-artifact@v3を使用して、レポーターによって生成された HTML ファイルを、後でアクセスできる場所にアップロードします。

すべてをまとめる

最後に、プロジェクトを GitHub にプッシュして、ワークフローの実行を確認する必要があります。GitHub アカウントに移動し、という名前の新しいリポジトリを作成してdelivery-api、リモート URL をコピーします。次に、プロジェクトで Git を初期化し、リモート URL を追加し、変更をコミットして、変更をプッシュします。

$ git init -b main
$ git remote add origin <your-remote-url>
$ git add .
$ git commit "<message>"
$ git push -u origin main

GitHub リポジトリでタブを開くとActions、ワークフローが実行中か失敗したかのいずれかが表示されます。これは、秘密鍵を追加していないためです。

これを解決するには、Postman で API キーを生成し、コレクションの UID も取得する必要があります。Postman ワークスペースに移動します。上部のメニューバーで、プロファイルをクリックして [設定]を選択します。サイドナビゲーションから[ API キー]を選択し、API キーを生成して値をコピーします。

次に、GETURL にリクエストを送信し、キーと生成した API キーと等しい値をhttps://api.getpostman.com/collectionsヘッダーに設定します。x-api-key応答には、コレクションのリストが含まれている必要があります。

リクエストレスポンスコレクションの取得

GitHub リポジトリに移動し、GitHub アクションシークレットにPOSTMAN_API_KEYとを追加します。POSTMAN_COLLECTION_UIDは、コレクションオブジェクトPOSTMAN_COLLECTION_UIDのuidフィールドです。Delivery-API Tests

Github リポジトリ Postman API Keyy

ここで、Actionsもう一度タブに移動して、失敗したジョブを再実行してみてください。すべてが正常に機能していればArtifacts、ワークフローから生成されたレポートであるファイルがパネルに表示されます。HTML ファイルをダウンロードして、ブラウザで開くことができます。

完成した Postman テストレポートファイル

以上です！API テストの自動化に成功しました。変更を加えて上流のブランチにプッシュするたびに、ワークフローがトリガーされ、テストが実行されます。理想的には、デプロイが行われた後にこのワークフローを実行したいと考えていますが、単純にするために、Postman テストのワークフローのみを定義しました。

API テストにおける Postman の制限事項

Postman は API テスト用の優れたツールですが、独自の制限があります。ソフトウェアの他のすべてと同様に、ジョブに適したツールを決定するには、独自のプロジェクトのニーズを考慮する必要があります。最初に考慮すべきことは、テストの範囲と複雑さです。外部サービスに依存するテストを作成する必要がある場合、それを簡単に自動化できない場合があります。

もう 1 つの制限は柔軟性です。アプリケーションロジックが存在する環境とは異なる環境でテストを記述しているため、コードの一部を共有して再利用することは困難です。これは、複数の異なるリクエストパラメータに対して API エンドポイントをテストする場合に特にイライラすることがあります。Postman は引き続きテスト用の優れたツールであり、テストに使用するかどうかについて十分な情報に基づいた決定を下すのは、開発者の責任です。

結論

この記事では、アプリケーションで API をテストすることが重要である理由を確認しました。Newman と GitHub Actions の設定を含め、Postman を使用して API をテストすることを検討しました。最後に、Postman のテストに関するいくつかの制限事項を確認しました。全体として、Postman は、API の構築、テスト、文書化、およびモックのための優れたツールです。このチュートリアルを楽しんで、コーディングを楽しんでいただければ幸いです。

ソース: https://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

顾静

1659792970

如何使用 Postman 自动化 API 测试

API 是您作为开发人员构建的几乎每个应用程序的驱动力，充当两个或多个软件组件之间的通信渠道。

但是，这种类型的系统的后果是一个组件的故障可能会对依赖它的其他组件产生重大影响。因此，广泛测试您的 API 以确保应用程序的正确性和可预测性至关重要。

有许多不同的方法可以测试您的 API，您选择的任何方法或方法组合最终将取决于您当前的业务需求、可用资源和实施细节。

在本文中，我们将探讨如何为将在 CI/CD 管道中运行的 API 编写自动化功能和集成测试。

为什么要自动化 API 测试？

编写测试有助于确保您的应用程序在任何给定时间的可预测性和正确性。因此，您应该在代码库更改时运行测试。像这样的重复性任务通常是自动化的良好候选者。

自动化测试让您有信心对应用程序进行更改和添加新功能，因为您始终可以依靠测试来指出您可能引入的错误。

使用 Postman 编写 API 测试

Postman是一个为构建、测试、记录和模拟 API 提供一整套工具的平台。作为开发人员，您很可能在本地开发时使用 Postman 向后端应用程序发出请求，但您可以用它做更多事情。

设置邮递员

要学习本教程，您需要一个 Postman 帐户。如果您还没有，请创建一个免费帐户。然后，导航到您的 Postman 工作区以开始使用。

我们将创建一个名为的新集合Delivery-API Tests，我们将在其中为我们将在本节稍后创建的交付 API 编写一些功能和集成测试。功能测试检查单个 API 端点的行为并确保请求-响应周期符合预期。另一方面，集成测试检查可以由两个或多个端点组成的特定流，以确定用户流中涉及的不同组件是否按预期工作。

此时，您的工作区应在左侧面板中显示该集合：

邮递员工作区集合

设置请求

接下来，我们需要创建将保存我们的测试的请求。一个请求将代表一个 API 端点。在Delivery-API Tests集合上，单击右侧出现的菜单按钮。

选择添加请求并命名创建的请求Search Deliveries。再创建三个名为Select Delivery、Confirm Pickup和的请求Complete Delivery。

现在，我们需要为每个请求编写测试。Postman 有一个内置的测试工具，允许您使用 JavaScript 语法编写测试。运行请求后立即执行测试，您可以在测试脚本中访问从请求返回的响应。

在Delivery-API Tests集合中，选择Search Deliveries请求并选择测试选项卡。将以下代码块粘贴到编辑器中：

const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains results", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("array")
    pm.expect(responseJson.data[0]).to.haveOwnProperty("status")
})

pm.collectionVariables.set("SELECTED_DELIVERY_ID", responseJson.data[0].id)

在上面的代码中，我们通过调用获取 JSON 格式的响应pm.response.json()。请注意，这pm是一个在所有请求脚本中都可用的全局对象。然后，我们使用pm.test.

如果您熟悉 JavaScript 中的测试，那么这里的语法应该很简单。Postman 支持Chai 断言库中的语法，因此您可以像在 JavaScript 中那样编写测试。

在测试用例中，我们正在检查正确的状态代码、返回的数据类型以及一些额外的必填字段。这些都是简单的测试，但目标是理解 Postman 中的测试概念。

请注意，在代码块的最后一行，我们设置了一个名为SELECTED_DELIVERY_ID. 集合变量是跨请求共享数据的一种直观方式。

接下来，我们要为其他请求编写测试。将以下代码块粘贴到相应的请求中：

// Select Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("QUEUED")
})


// Confirm Pickup
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("PICKED_UP")
})


// Complete Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("COMPLETED")
})

除了字段上的断言外，其他请求的测试用例是相同的status。现在我们已经对我们的请求进行了测试，让我们运行它们。我们需要创建一个处理 API 请求的后端服务器。您可以使用任何语言或框架实现后端服务器，只要它符合 REST 标准，但在本文中，我们将使用Koa构建一个简单的 Node.js 服务器。

构建 API 服务器

在您的终端中，创建一个文件夹并使用 Yarn 或 npm 初始化一个 Node.js 项目：

$ mkdir delivery-api
$ cd delivery-api
$ yarn init -y

现在，创建一个名为app.js并安装必要的依赖项的文件：

$ touch app.js
$ yarn add koa @koa/router

在您的package.json文件中，添加以下脚本：

//...
  "scripts": {
    "start": "node app.js"
  },
//...

Koa 是一个用于 Node.js 的轻量级 HTTP 中间件框架，类似于 Express。让我们初始化一个 Koa 服务器并定义与我们在 Postman 中设置的请求相对应的路由处理程序。在您的app.js文件中，粘贴以下代码块：

const Koa = require("koa");
const Router = require("@koa/router");
const app = new Koa();
const router = new Router();

app.use(router.routes());

const deliveries = [
   {
      id: "1",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148928000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148928000",
      instructions: "",
      status: "CREATED",
   },
   {
      id: "2",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148915000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148915000",
      instructions: "",
      status: "CREATED",
   },
];

router.get("/deliveries", (ctx) => {
   ctx.body = {
      status: "00",
      message: "successs",
      data: deliveries,
   };
});

router.get("/deliveries/:id/select", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "QUEUED" },
   };
});

router.get("/deliveries/:id/confirm-pickup", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "PICKED_UP" },
   };
});

router.get("/deliveries/:id/complete", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "COMPLETED" },
   };
});

app.listen(8000);

这里发生了很多事情，所以让我们分解一下。首先，我们初始化一个新的 Koa 应用程序和一个新Router对象。使用该router实例，我们定义了四个路由，其路径与我们在 Postman 中创建的请求相匹配。最后，我们通过调用来启动服务器app.listen()。

总之，这个简单的 API 服务器试图模拟送餐应用程序的订单交付过程。现在，通过yarn start在终端中运行来启动服务器。

在 Postman 上运行手动测试

现在，我们已经设置好一切来运行测试。如果您在网络上使用 Postman，您将无法连接到localhost. 但是，有两种方法可以解决此问题。您可以下载Postman 桌面应用程序或使用ngrok作为隧道将您的localhost端口公开到互联网。

如果您决定使用 ngrok，您需要做的就是安装它并启动一个指向您的服务器的隧道。打开另一个终端实例，然后运行以下命令并复制显示的 URL：

$ ngrok http 8000

URL 应类似于https://3d43-154-130-109-210.ngrok.io. 在 Web 或桌面上导航到 Postman，选择Delivery-API Tests集合，然后打开变量选项卡。

如果您不使用 Postman 桌面，请使用API_BASE_URL键添加变量并将值设置为或 ngrok URL。http://localhost:8000添加新变量时请务必点击Persist All以确保外部服务可以访问它：

Postman 变量传递 API 测试

现在，我们可以为每个请求使用集合变量。将每个请求的 URL 字段更新为以下值：

Search Deliveries：{{API_BASE_URL}}/deliveries?page=1&count=20
Select Delivery：{{API_BASE_URL}}/deliveries/:id/select
Confirm Pickup：{{API_BASE_URL}}/deliveries/:id/confirm-pickup
Complete Delivery：{{API_BASE_URL}}/deliveries/:id/complete

我们可以使用两种方法之一手动运行我们的测试。第一种是单独运行请求，允许执行每个请求的测试脚本。或者，我们可以使用集合运行器一次运行集合。我们将在下一节中使用收集运行器，但您可以通过单击“发送”按钮临时手动运行每个请求。

当您运行请求时，您会在底部面板中看到响应，但您也可以通过单击底部面板中的测试结果选项卡来查看测试结果：

邮递员测试结果选项卡

这就是在 Postman 中运行测试所需要做的一切。但是，每当您对代码库进行更改时，访问您的 Postman 工作区并运行测试都感觉不直观。这种方法与开发工作流程不一致，所以让我们对其进行改进。

自动化您的 API 测试

在本节中，我们将通过自动化工作流程使测试过程更直观、更省时。优化的开发工作流程涉及进行本地更改并将新功能推送到源代码控制，在那里它们被 CI/CD 管道拾取，触发一些构建或部署任务。

Postman 提供了一个名为 Newman 的命令行工具，可让您从 CLI 运行集合。它还提供与 CI/CD 环境的无缝集成，这意味着我们可以将测试设置为在部署步骤中运行。这极大地简化了测试过程，使我们不必经常在工作区中运行测试。

将 Newman 与 GitHub Actions 集成

我们可以在许多持续集成服务中设置纽曼。在本文中，我们将使用 GitHub Actions。让我们首先为 Newman 定义一个工作流程。在您的delivery-api项目中，运行以下命令：

$ mkdir .github
$ mkdir .github/workflows
$ touch .github/workflows/postman-tests.yml

将以下工作流定义添加到postman-tests.yml文件中：

# postman-tests.yml
name: Newman Run
on:
  push:
    branches:
      - main
  # types: [closed]
jobs:
  newman:
    name: Postman-tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Node
        uses: actions/setup-node@v3
        with:
          node-version: 14
      - name: Install Newman & Reporter
        run: |
          npm install -g newman
          npm install -g newman-reporter-htmlextra
      # Make directory for test results in workspace
      - name: Make Directory
        run: mkdir -p newman-results
      # Run newman cli
      - name: Run Newman
        env:
          POSTMAN_API_URL: 'https://api.getpostman.com'
          POSTMAN_API_KEY: ${{ secrets.POSTMAN_API_KEY }}
          POSTMAN_COLLECTION_UID: ${{ secrets.POSTMAN_COLLECTION_UID }}
        run: |
          newman run "${{env.POSTMAN_API_URL}}/collections/${{env.POSTMAN_COLLECTION_UID}}?apikey=${{env.POSTMAN_API_KEY}}" \
          -r htmlextra,cli --reporter-htmlextra-export newman-results/htmlreport.html
      # Upload test results to workspace
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: Postman_Test_Reports
          path: newman-results

上面的代码是一个简单的工作流，当我们推送到存储库时运行，特别是在默认main分支上。我们通过一系列步骤为 Postman 测试定义一个作业。

首先，我们运行 checkout 操作，然后使用预定义的操作安装actions/setup-node@v3Node.js。接下来，我们安装 Newman 和newman-reporter-htmlextra. Reporter 是 Newman 的一个插件，可以生成 HTML 格式的测试摘要。然后，我们使用一些参数运行 Newman CLI 工具，包括我们集合的 Postman API URL。

请注意，我们已经定义了一些环境变量。和正在从 GitHub Action 机密中提取POSTMAN_API_KEY。POSTMAN_COLLECTION_UID在设置这些秘密之前，我们需要创建一个存储库。最后，在运行 Newman 之后，我们使用预定义的操作actions/upload-artifact@v3将记者生成的 HTML 文件上传到我们以后可以访问的位置。

把这一切放在一起

最后，我们需要将项目推送到 GitHub 并查看工作流运行情况。导航到您的 GitHub 帐户，创建一个名为的新存储库delivery-api，然后复制远程 URL。接下来，我们将在项目中初始化 Git，添加远程 URL，提交我们的更改，然后推送更改：

$ git init -b main
$ git remote add origin <your-remote-url>
$ git add .
$ git commit "<message>"
$ git push -u origin main

如果您Actions在 GitHub 存储库中打开选项卡，您应该会看到工作流正在运行或已失败。这是因为我们没有添加密钥。

为了解决这个问题，我们需要在 Postman 上生成一个 API 密钥并获取集合 UID。导航到您的 Postman 工作区；在顶部菜单栏中，单击您的个人资料并选择设置。从侧面导航中选择API Keys，然后生成 API 密钥并复制该值。

接下来，GET向 URL 发出请求，并使用与您生成的 API 密钥相等https://api.getpostman.com/collections的密钥和值设置标头。x-api-key您的回复应包含您的收藏列表：

获取请求响应集合

转到您的 GitHub 存储库并在 GitHub 操作机密中添加POSTMAN_API_KEY和。是您POSTMAN_COLLECTION_UID的集合对象中的字段。POSTMAN_COLLECTION_UIDuidDelivery-API Tests

Github 存储库 Postman API Keyy

现在，再次转到您的Actions选项卡并尝试重新运行失败的作业。如果一切正常，您应该会在Artifacts面板中看到一个文件，该文件是工作流生成的报告。您可以在浏览器中下载并打开 HTML 文件。

完成的邮递员测试报告文件

就是这样！我们已经成功地自动化了我们的 API 测试。每次我们进行更改并推送到上游分支时，它都会触发工作流，运行我们的测试。理想情况下，我们希望在部署完成后运行这个工作流，但为了简单起见，我们只定义了 Postman 测试的工作流。

Postman 对 API 测试的限制

Postman 是一个很棒的 API 测试工具，但它也有其自身的局限性。与软件中的其他所有内容一样，您需要考虑您独特的项目需求来确定适合该工作的工具。首先要考虑的是测试的范围和复杂性。如果您需要编写依赖于某些外部服务的测试，您可能无法轻松实现自动化。

另一个限制是灵活性。因为您在与应用程序逻辑所在的环境不同的环境中编写测试，所以很难共享和重用代码片段。当您想要针对多个不同的请求参数测试 API 端点时，这尤其令人沮丧。Postman 仍然是一个很好的测试工具，作为开发人员，您可以就使用它进行测试做出明智的决定。

结论

在本文中，我们回顾了为什么在您的应用程序中测试 API 很重要。我们探索了使用 Postman 测试我们的 API，包括设置 Newman 和 GitHub Actions。最后，我们回顾了 Postman 的一些测试限制。总体而言，Postman 是构建、测试、记录和模拟 API 的绝佳工具。我希望您喜欢本教程，并祝您编码愉快！

来源：https ://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

Berta Escamilla

1659789193

Cómo Automatizar Pruebas De API Con Postman

Las API son la fuerza impulsora detrás de prácticamente todas las aplicaciones que creará como desarrollador y sirven como un canal de comunicación entre dos o más componentes de software.

Sin embargo, la consecuencia de este tipo de sistema es que la falla de un componente puede tener un impacto significativo en los otros componentes que dependen de él. Por lo tanto, es fundamental probar exhaustivamente sus API para garantizar la corrección y la previsibilidad de su aplicación.

Hay muchas formas diferentes de probar sus API, y cualquier método o combinación de métodos que elija dependerá en última instancia de sus necesidades comerciales actuales, los recursos disponibles y los detalles de implementación.

En este artículo, exploraremos cómo escribir pruebas funcionales y de integración automatizadas para sus API que se ejecutarán en una canalización de CI/CD.

¿Por qué deberías automatizar tus pruebas de API?

Escribir pruebas ayuda a garantizar la previsibilidad y corrección de sus aplicaciones en un momento dado. Por lo tanto, debe ejecutar pruebas tan a menudo como cambie su base de código. Las tareas repetitivas como esta suelen ser buenas candidatas para la automatización.

Las pruebas automatizadas le brindan la confianza para realizar cambios y agregar nuevas funciones a su aplicación porque siempre puede confiar en sus pruebas para señalar los errores que podría haber introducido.

Escribir pruebas de API con Postman

Postman es una plataforma que proporciona un conjunto completo de herramientas para crear, probar, documentar y simular API. Como desarrollador, lo más probable es que haya utilizado Postman para realizar solicitudes a su aplicación de back-end mientras desarrollaba localmente, pero puede hacer aún más con él.

Configuración del cartero

Para seguir este tutorial, necesitará una cuenta de Postman. Si aún no tienes una, crea una cuenta gratuita . Luego, navegue a su espacio de trabajo de Postman para comenzar.

Crearemos una nueva colección llamada Delivery-API Testsdonde escribiremos algunas pruebas funcionales y de integración para una API de entrega que crearemos más adelante en esta sección. Una prueba funcional verifica el comportamiento de un único punto final de API y garantiza que el ciclo de solicitud-respuesta se ajuste a las expectativas. Por otro lado, las pruebas de integración verifican flujos específicos que pueden estar compuestos por dos o más puntos finales para determinar si los diferentes componentes involucrados en un flujo de usuario funcionan como se espera.

En este punto, su espacio de trabajo debería mostrar la colección en el panel izquierdo:

Colección de espacio de trabajo de cartero

Configuración de solicitudes

A continuación, necesitaremos crear solicitudes que contengan nuestras pruebas. Una solicitud representará un punto final de API. En la Delivery-API Testscolección, haz clic en el botón de menú que aparece a la derecha.

Seleccione Agregar solicitud y asigne un nombre a la solicitud que se crea Search Deliveries. Cree tres solicitudes más denominadas Select Delivery, Confirm Pickupy Complete Delivery.

Ahora, necesitamos escribir las pruebas para cada solicitud. Postman tiene una herramienta de prueba integrada que le permite escribir pruebas utilizando la sintaxis de JavaScript. Las pruebas se ejecutan inmediatamente después de que se ejecuta una solicitud y puede acceder a la respuesta devuelta de la solicitud en el script de prueba.

En la Delivery-API Testscolección, seleccione la Search Deliveriessolicitud y seleccione la pestaña Pruebas . Pegue el siguiente bloque de código en el editor:

const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains results", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("array")
    pm.expect(responseJson.data[0]).to.haveOwnProperty("status")
})

pm.collectionVariables.set("SELECTED_DELIVERY_ID", responseJson.data[0].id)

En el código anterior, obtenemos la respuesta en formato JSON llamando a pm.response.json(). Tenga en cuenta que pmes un objeto global disponible en todos los scripts de solicitud. Luego definimos dos casos de prueba usando pm.test.

Si está familiarizado con las pruebas en JavaScript , entonces la sintaxis aquí debería ser sencilla. Postman admite la sintaxis de la biblioteca de aserciones de Chai , por lo que puede escribir pruebas de la misma manera que ya lo hace en JavaScript.

En los casos de prueba, verificamos el código de estado correcto, el tipo de datos devueltos y algunos campos obligatorios adicionales. Estas son pruebas simples, pero el objetivo es comprender el concepto de prueba en Postman.

Tenga en cuenta que en la última línea del bloque de código, estamos configurando una variable de colección llamada SELECTED_DELIVERY_ID. Las variables de colección son una forma intuitiva de compartir datos entre solicitudes.

A continuación, queremos escribir pruebas para las otras solicitudes. Pegue los siguientes bloques de código en las solicitudes correspondientes:

// Select Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("QUEUED")
})


// Confirm Pickup
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("PICKED_UP")
})


// Complete Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("COMPLETED")
})

Los casos de prueba para otras solicitudes son idénticos excepto por la aserción en el statuscampo. Ahora que tenemos pruebas para nuestras solicitudes, vamos a ejecutarlas. Tendremos que crear un servidor back-end que manejará las solicitudes de API. Puede implementar el servidor back-end en cualquier idioma o marco, siempre que sea compatible con REST, pero en este artículo, construiremos un servidor Node.js simple usando Koa .

Construyendo el servidor API

En su terminal, cree una carpeta e inicialice un proyecto Node.js con Yarn o npm:

$ mkdir delivery-api
$ cd delivery-api
$ yarn init -y

Ahora, crea un archivo llamado app.jse instala las dependencias necesarias:

$ touch app.js
$ yarn add koa @koa/router

En su package.jsonarchivo, agregue el siguiente script:

//...
  "scripts": {
    "start": "node app.js"
  },
//...

Koa es un framework de middleware HTTP ligero para Node.js que es similar a Express. Inicialicemos un servidor Koa y definamos los controladores de ruta que corresponden a las solicitudes que configuramos en Postman. En su app.jsarchivo, pegue el bloque de código a continuación:

const Koa = require("koa");
const Router = require("@koa/router");
const app = new Koa();
const router = new Router();

app.use(router.routes());

const deliveries = [
   {
      id: "1",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148928000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148928000",
      instructions: "",
      status: "CREATED",
   },
   {
      id: "2",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148915000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148915000",
      instructions: "",
      status: "CREATED",
   },
];

router.get("/deliveries", (ctx) => {
   ctx.body = {
      status: "00",
      message: "successs",
      data: deliveries,
   };
});

router.get("/deliveries/:id/select", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "QUEUED" },
   };
});

router.get("/deliveries/:id/confirm-pickup", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "PICKED_UP" },
   };
});

router.get("/deliveries/:id/complete", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "COMPLETED" },
   };
});

app.listen(8000);

Están sucediendo muchas cosas aquí, así que vamos a desglosarlo. Primero, inicializamos una nueva aplicación Koa y un nuevo Routerobjeto. Usando la routerinstancia, definimos cuatro rutas con rutas que coinciden con las solicitudes que creamos en Postman. Finalmente, iniciamos el servidor llamando a app.listen().

En resumen, este servidor API simple intenta simular el proceso de entrega de un pedido para una aplicación de entrega de alimentos. Ahora, inicie el servidor ejecutándolo yarn starten su terminal.

Ejecución de pruebas manuales en Postman

Ahora, tenemos todo configurado para ejecutar las pruebas. Si usa Postman en la web, no podrá conectarse a localhost. Sin embargo, hay dos maneras de evitar esto. Puede descargar la aplicación de escritorio Postman o usar ngrok como un túnel para exponer su localhostpuerto a Internet.

Si decide usar ngrok, todo lo que necesita hacer es instalarlo e iniciar un túnel que apunte a su servidor. Abra otra instancia de terminal, luego ejecute el siguiente comando y copie la URL que se muestra:

$ ngrok http 8000

La URL debe ser similar a https://3d43-154-130-109-210.ngrok.io. Vaya a Postman, ya sea en la web o en el escritorio, seleccione la Delivery-API Testscolección y abra la pestaña de variables .

Agregue una variable con la API_BASE_URLclave y establezca el valor en http://localhost:8000o la URL de ngrok si no está utilizando el escritorio de Postman. Asegúrese de hacer clic en Conservar todo cuando agregue una nueva variable para asegurarse de que los servicios externos puedan acceder a ella:

Pruebas API de entrega de variables de cartero

Ahora, podemos usar la variable de colección para cada solicitud. Actualice el campo URL para cada solicitud a los siguientes valores:

Search Deliveries:{{API_BASE_URL}}/deliveries?page=1&count=20
Select Delivery:{{API_BASE_URL}}/deliveries/:id/select
Confirm Pickup:{{API_BASE_URL}}/deliveries/:id/confirm-pickup
Complete Delivery:{{API_BASE_URL}}/deliveries/:id/complete

Podemos ejecutar nuestras pruebas manualmente usando uno de dos métodos. La primera es ejecutar las solicitudes individualmente, lo que permite ejecutar el script de prueba para cada solicitud. Alternativamente, podemos ejecutar la colección de una sola vez usando el ejecutor de la colección. Usaremos el ejecutor de recopilación en la siguiente sección, pero puede ejecutar temporalmente cada solicitud manualmente haciendo clic en el botón Enviar .

Cuando ejecuta una solicitud, verá la respuesta en el panel inferior, pero también puede ver los resultados de la prueba haciendo clic en la pestaña Resultados de la prueba en el panel inferior:

Pestaña de resultados de la prueba del cartero

Eso es todo lo que necesita hacer para ejecutar una prueba en Postman. Sin embargo, parece poco intuitivo visitar su espacio de trabajo de Postman y ejecutar pruebas cada vez que realiza cambios en su base de código. Este enfoque no se alinea con el flujo de trabajo de desarrollo, así que mejorémoslo.

Automatización de sus pruebas de API

En esta sección, haremos que el proceso de prueba sea más intuitivo y consuma menos tiempo al automatizar el flujo de trabajo. El flujo de trabajo de desarrollo optimizado implica realizar cambios locales y enviar nuevas funciones al control de código fuente, donde la canalización de CI/CD las recoge, lo que desencadena algunas tareas de compilación o implementación.

Postman proporciona una herramienta de línea de comandos llamada Newman que le permite ejecutar colecciones desde la CLI. También ofrece una integración perfecta con los entornos de CI/CD, lo que significa que podemos configurar nuestras pruebas para que se ejecuten durante un paso de implementación. Esto simplifica enormemente el proceso de prueba, evitando que tengamos que ejecutar pruebas constantemente en el espacio de trabajo.

Integración de Newman con acciones de GitHub

Podemos configurar Newman en muchos servicios de integración continua. En este artículo, usaremos GitHub Actions. Comencemos definiendo un flujo de trabajo para Newman. En su delivery-apiproyecto, ejecute los siguientes comandos:

$ mkdir .github
$ mkdir .github/workflows
$ touch .github/workflows/postman-tests.yml

Agregue la siguiente definición de flujo de trabajo al postman-tests.ymlarchivo:

# postman-tests.yml
name: Newman Run
on:
  push:
    branches:
      - main
  # types: [closed]
jobs:
  newman:
    name: Postman-tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Node
        uses: actions/setup-node@v3
        with:
          node-version: 14
      - name: Install Newman & Reporter
        run: |
          npm install -g newman
          npm install -g newman-reporter-htmlextra
      # Make directory for test results in workspace
      - name: Make Directory
        run: mkdir -p newman-results
      # Run newman cli
      - name: Run Newman
        env:
          POSTMAN_API_URL: 'https://api.getpostman.com'
          POSTMAN_API_KEY: ${{ secrets.POSTMAN_API_KEY }}
          POSTMAN_COLLECTION_UID: ${{ secrets.POSTMAN_COLLECTION_UID }}
        run: |
          newman run "${{env.POSTMAN_API_URL}}/collections/${{env.POSTMAN_COLLECTION_UID}}?apikey=${{env.POSTMAN_API_KEY}}" \
          -r htmlextra,cli --reporter-htmlextra-export newman-results/htmlreport.html
      # Upload test results to workspace
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: Postman_Test_Reports
          path: newman-results

El código anterior es un flujo de trabajo simple que se ejecuta cuando ingresamos al repositorio, específicamente en la mainrama predeterminada. Definimos un trabajo para las pruebas de Postman con una serie de pasos.

Primero, ejecutamos la acción de pago, luego instalamos Node.js usando una acción predefinida actions/setup-node@v3. A continuación, instalamos Newman y newman-reporter-htmlextra. El reportero es un complemento para Newman que genera un resumen de las pruebas en formato HTML. Luego ejecutamos la herramienta CLI de Newman con algunos argumentos, incluida la URL de la API de Postman para nuestra colección.

Tenga en cuenta que hemos definido algunas variables de entorno. Los POSTMAN_API_KEYy POSTMAN_COLLECTION_UIDse extraen de los secretos de GitHub Action. Antes de configurar estos secretos, necesitaremos crear un repositorio. Finalmente, después de ejecutar Newman, usamos la acción predefinida actions/upload-artifact@v3para cargar el archivo HTML generado por el reportero en una ubicación a la que podamos acceder más adelante.

Reuniéndolo todo

Finalmente, necesitamos enviar el proyecto a GitHub y ver cómo se ejecuta el flujo de trabajo. Navegue a su cuenta de GitHub, cree un nuevo repositorio llamado delivery-apiy copie la URL remota. A continuación, inicializaremos Git en el proyecto, agregaremos la URL remota, confirmaremos nuestros cambios y enviaremos los cambios:

$ git init -b main
$ git remote add origin <your-remote-url>
$ git add .
$ git commit "<message>"
$ git push -u origin main

Si abre la Actionspestaña en su repositorio de GitHub, debería ver el flujo de trabajo ejecutándose o fallando. Esto se debe a que no hemos agregado las claves secretas.

Para resolver esto, necesitamos generar una clave API en Postman y también obtener el UID de la colección. Navegue a su espacio de trabajo de Postman; en la barra de menú superior, haga clic en su perfil y seleccione Configuración . Seleccione Claves de API en la navegación lateral, luego genere una clave de API y copie el valor.

A continuación, realice una GETsolicitud a la URL https://api.getpostman.com/collectionsy establezca un encabezado con la clave x-api-keyy un valor igual a la clave API que generó. Su respuesta debe contener una lista de sus colecciones:

Obtener colecciones de respuestas a solicitudes

Vaya a su repositorio de GitHub y agregue POSTMAN_API_KEYy POSTMAN_COLLECTION_UIDen los secretos de GitHub Action. El POSTMAN_COLLECTION_UIDes el uidcampo en su Delivery-API Testsobjeto de colección.

Repositorio Github Postman API Keyy

Ahora, vaya a su Actionspestaña nuevamente e intente volver a ejecutar los trabajos fallidos. Si todo funcionó bien, debería ver un archivo en el Artifactspanel, que es el informe generado del flujo de trabajo. Puede descargar y abrir el archivo HTML en su navegador.

Archivo de informes de prueba de cartero completado

¡Y eso es! Hemos automatizado con éxito nuestras pruebas API. Cada vez que hacemos cambios y subimos a la rama ascendente, activará el flujo de trabajo y ejecutará nuestras pruebas. Idealmente, queremos ejecutar este flujo de trabajo después de que se haya realizado una implementación, pero para simplificar, definimos solo el flujo de trabajo de las pruebas de Postman.

Limitaciones de Postman para pruebas de API

Postman es una gran herramienta para las pruebas de API, sin embargo, tiene sus propias limitaciones. Como todo lo demás en software, querrá considerar las necesidades únicas de su proyecto para determinar la herramienta adecuada para el trabajo. Lo primero que debe considerar es el alcance y la complejidad de sus pruebas. Si necesita escribir pruebas que dependen de algún servicio externo, es posible que no pueda automatizar eso fácilmente.

Otra limitación es la flexibilidad. Debido a que está escribiendo pruebas en un entorno diferente de donde vive la lógica de su aplicación, es difícil compartir y reutilizar fragmentos de código. Esto puede ser especialmente frustrante cuando desea probar un punto final de API con varios parámetros de solicitud diferentes. Postman sigue siendo una excelente herramienta para realizar pruebas y depende de usted, como desarrollador, tomar decisiones informadas sobre su uso para las pruebas.

Conclusión

En este artículo, revisamos por qué es importante probar las API en su aplicación. Exploramos probar nuestras API usando Postman, incluida la configuración de Newman y GitHub Actions. Finalmente, revisamos algunas de las limitaciones de Postman para las pruebas. En general, Postman es una excelente herramienta para crear, probar, documentar y simular API. ¡Espero que hayas disfrutado este tutorial y feliz codificación!

Fuente: https://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

Cómo Automatizar Pruebas De API Con Postman

Anne de Morel

1659789000

Comment Automatiser Les Tests D'API Avec Postman

Les API sont la force motrice de pratiquement toutes les applications que vous créerez en tant que développeur, servant de canal de communication entre deux composants logiciels ou plus.

Cependant, la conséquence de ce type de système est que la défaillance d'un composant peut avoir un impact important sur les autres composants qui en dépendent. Par conséquent, il est crucial de tester vos API de manière approfondie pour garantir l'exactitude et la prévisibilité de votre application.

Il existe de nombreuses façons différentes de tester vos API, et la méthode ou la combinaison de méthodes que vous choisissez dépendra en fin de compte de vos besoins commerciaux actuels, des ressources disponibles et des détails de mise en œuvre.

Dans cet article, nous allons explorer comment écrire des tests fonctionnels et d'intégration automatisés pour vos API qui s'exécuteront dans un pipeline CI/CD.

Pourquoi devriez-vous automatiser vos tests d'API ?

La rédaction de tests aide à garantir la prévisibilité et l'exactitude de vos applications à tout moment. Par conséquent, vous devez exécuter des tests aussi souvent que votre base de code change. Les tâches répétitives comme celle-ci sont souvent de bons candidats pour l'automatisation.

Les tests automatisés vous donnent la confiance nécessaire pour apporter des modifications et ajouter de nouvelles fonctionnalités à votre application, car vous pouvez toujours compter sur vos tests pour signaler les bogues que vous pourriez avoir introduits.

Rédaction de tests API avec Postman

Postman est une plate-forme qui fournit un ensemble complet d'outils pour créer, tester, documenter et simuler des API. En tant que développeur, vous avez très probablement utilisé Postman pour envoyer des requêtes à votre application backend tout en développant localement, mais vous pouvez en faire encore plus.

Configuration du facteur

Pour suivre ce didacticiel, vous aurez besoin d'un compte Postman. Si vous n'en avez pas déjà un, créez un compte gratuit . Ensuite, accédez à votre espace de travail Postman pour commencer.

Nous allons créer une nouvelle collection appelée Delivery-API Testsoù nous écrirons des tests fonctionnels et d'intégration pour une API de livraison que nous créerons plus tard dans cette section. Un test fonctionnel vérifie le comportement d'un point de terminaison d'API unique et garantit que le cycle requête-réponse est conforme aux attentes. D'autre part, les tests d'intégration vérifient des flux spécifiques qui peuvent être constitués de deux points de terminaison ou plus pour déterminer si les différents composants impliqués dans un flux utilisateur fonctionnent comme prévu.

À ce stade, votre espace de travail doit afficher la collection dans le panneau de gauche :

Collection d'espace de travail du facteur

Paramétrage des requêtes

Ensuite, nous devrons créer des requêtes qui contiendront nos tests. Une demande représentera un point de terminaison d'API. Sur la Delivery-API Testscollection, cliquez sur le bouton de menu qui apparaît à droite.

Sélectionnez Ajouter une demande et nommez la demande qui est créée Search Deliveries. Créez trois autres requêtes nommées Select Delivery, Confirm Pickupet Complete Delivery.

Maintenant, nous devons écrire les tests pour chaque requête. Postman dispose d'un outil de test intégré qui vous permet d'écrire des tests à l'aide de la syntaxe JavaScript. Les tests sont exécutés immédiatement après l'exécution d'une requête et vous pouvez accéder à la réponse renvoyée par la requête dans le script de test.

Dans la Delivery-API Testscollection, sélectionnez la Search Deliveriesrequête et sélectionnez l' onglet Tests . Collez le bloc de code suivant dans l'éditeur :

const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains results", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("array")
    pm.expect(responseJson.data[0]).to.haveOwnProperty("status")
})

pm.collectionVariables.set("SELECTED_DELIVERY_ID", responseJson.data[0].id)

Dans le code ci-dessus, nous obtenons la réponse au format JSON en appelant pm.response.json(). Notez qu'il pms'agit d'un objet global disponible dans tous les scripts de requête. Nous avons ensuite défini deux cas de test en utilisant pm.test.

Si vous êtes familier avec les tests en JavaScript , la syntaxe ici devrait être simple. Postman prend en charge la syntaxe de la bibliothèque d'assertions Chai , vous pouvez donc écrire des tests de la même manière que vous le faites déjà en JavaScript.

Dans les scénarios de test, nous vérifions le code d'état correct, le type de données renvoyées et certains champs obligatoires supplémentaires. Ce sont des tests simples, mais le but est de comprendre le concept de test dans Postman.

Notez que dans la dernière ligne du bloc de code, nous définissons une variable de collection appelée SELECTED_DELIVERY_ID. Les variables de collection sont un moyen intuitif de partager des données entre les requêtes.

Ensuite, nous voulons écrire des tests pour les autres requêtes. Collez les blocs de code suivants dans les requêtes correspondantes :

// Select Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("QUEUED")
})


// Confirm Pickup
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("PICKED_UP")
})


// Complete Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("COMPLETED")
})

Les cas de test pour les autres requêtes sont identiques à l'exception de l'assertion sur le statuschamp. Maintenant que nous avons des tests pour nos requêtes, exécutons-les. Nous devrons créer un serveur principal qui gérera les requêtes API. Vous pouvez implémenter le serveur principal dans n'importe quel langage ou framework tant qu'il est compatible REST, mais dans cet article, nous allons créer un serveur Node.js simple à l'aide de Koa .

Construire le serveur API

Dans votre terminal, créez un dossier et initialisez un projet Node.js avec Yarn ou npm :

$ mkdir delivery-api
$ cd delivery-api
$ yarn init -y

Maintenant, créez un fichier appelé app.jset installez les dépendances nécessaires :

$ touch app.js
$ yarn add koa @koa/router

Dans votre package.jsonfichier, ajoutez le script suivant :

//...
  "scripts": {
    "start": "node app.js"
  },
//...

Koa est un framework middleware HTTP léger pour Node.js similaire à Express. Initialisons un serveur Koa et définissons les gestionnaires de route qui correspondent aux requêtes que nous avons configurées dans Postman. Dans votre app.jsfichier, collez le bloc de code ci-dessous :

const Koa = require("koa");
const Router = require("@koa/router");
const app = new Koa();
const router = new Router();

app.use(router.routes());

const deliveries = [
   {
      id: "1",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148928000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148928000",
      instructions: "",
      status: "CREATED",
   },
   {
      id: "2",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148915000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148915000",
      instructions: "",
      status: "CREATED",
   },
];

router.get("/deliveries", (ctx) => {
   ctx.body = {
      status: "00",
      message: "successs",
      data: deliveries,
   };
});

router.get("/deliveries/:id/select", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "QUEUED" },
   };
});

router.get("/deliveries/:id/confirm-pickup", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "PICKED_UP" },
   };
});

router.get("/deliveries/:id/complete", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "COMPLETED" },
   };
});

app.listen(8000);

Il se passe beaucoup de choses ici, alors décomposons-le. Tout d'abord, nous initialisons une nouvelle application Koa et un nouvel Routerobjet. À l'aide de l' routerinstance, nous définissons quatre routes avec des chemins correspondant aux requêtes que nous avons créées dans Postman. Enfin, nous démarrons le serveur en appelant app.listen().

En résumé, ce simple serveur API tente de simuler le processus de livraison d'une commande pour une application de livraison de nourriture. Maintenant, démarrez le serveur en l'exécutant yarn startdans votre terminal.

Exécution de tests manuels sur Postman

Maintenant, nous avons tout mis en place pour exécuter les tests. Si vous utilisez Postman sur le Web, vous ne pourrez pas vous connecter à localhost. Cependant, il existe deux façons de contourner cela. Vous pouvez soit télécharger l' application de bureau Postman , soit utiliser ngrok comme tunnel pour exposer votre localhostport à Internet.

Si vous décidez d'utiliser ngrok, il vous suffit de l'installer et de démarrer un tunnel pointant vers votre serveur. Ouvrez une autre instance de terminal, puis exécutez la commande suivante et copiez l'URL affichée :

$ ngrok http 8000

L'URL doit être similaire à https://3d43-154-130-109-210.ngrok.io. Accédez à Postman, sur le Web ou sur le bureau, sélectionnez la Delivery-API Testscollection et ouvrez l' onglet des variables .

Ajoutez une variable avec la API_BASE_URLclé et définissez la valeur sur http://localhost:8000ou l'URL ngrok si vous n'utilisez pas le bureau Postman. Assurez-vous de cliquer sur Tout conserver lors de l'ajout d'une nouvelle variable pour vous assurer que les services externes peuvent y accéder :

Tests de l'API de livraison des variables Postman

Maintenant, nous pouvons utiliser la variable de collection pour chaque requête. Mettez à jour le champ URL de chaque requête avec les valeurs suivantes :

Search Deliveries:{{API_BASE_URL}}/deliveries?page=1&count=20
Select Delivery:{{API_BASE_URL}}/deliveries/:id/select
Confirm Pickup:{{API_BASE_URL}}/deliveries/:id/confirm-pickup
Complete Delivery:{{API_BASE_URL}}/deliveries/:id/complete

Nous pouvons exécuter nos tests manuellement en utilisant l'une des deux méthodes. La première consiste à exécuter les requêtes individuellement, permettant au script de test de chaque requête d'être exécuté. Alternativement, nous pouvons exécuter la collecte en une seule fois à l'aide du coureur de collecte. Nous utiliserons l'exécuteur de collecte dans la section suivante, mais vous pouvez exécuter temporairement chaque demande manuellement en cliquant sur le bouton Envoyer .

Lorsque vous exécutez une requête, vous verrez la réponse dans le panneau inférieur, mais vous pouvez également voir les résultats du test en cliquant sur l' onglet Test Results dans le panneau inférieur :

Onglet Résultats du test Postman

C'est tout ce que vous devez faire pour exécuter un test dans Postman. Cependant, il n'est pas intuitif de visiter votre espace de travail Postman et d'exécuter des tests chaque fois que vous apportez des modifications à votre base de code. Cette approche ne correspond pas au flux de travail de développement, alors améliorons-la.

Automatisation de vos tests d'API

Dans cette section, nous rendrons le processus de test plus intuitif et moins long en automatisant le flux de travail. Le flux de travail de développement optimisé implique d'apporter des modifications locales et de pousser les nouvelles fonctionnalités vers le contrôle de code source, où elles sont récupérées par le pipeline CI/CD, déclenchant certaines tâches de construction ou de déploiement.

Postman fournit un outil de ligne de commande appelé Newman qui vous permet d'exécuter des collections à partir de la CLI. Il offre également une intégration transparente avec les environnements CI/CD, ce qui signifie que nous pouvons configurer nos tests pour qu'ils s'exécutent lors d'une étape de déploiement. Cela simplifie grandement le processus de test, nous évitant d'avoir constamment à exécuter des tests dans l'espace de travail.

Intégration de Newman aux actions GitHub

Nous pouvons mettre en place Newman dans de nombreux services d'intégration continue. Dans cet article, nous utiliserons les actions GitHub. Commençons par définir un workflow pour Newman. Dans votre delivery-apiprojet, exécutez les commandes suivantes :

$ mkdir .github
$ mkdir .github/workflows
$ touch .github/workflows/postman-tests.yml

Ajoutez la définition de workflow suivante au postman-tests.ymlfichier :

# postman-tests.yml
name: Newman Run
on:
  push:
    branches:
      - main
  # types: [closed]
jobs:
  newman:
    name: Postman-tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Node
        uses: actions/setup-node@v3
        with:
          node-version: 14
      - name: Install Newman & Reporter
        run: |
          npm install -g newman
          npm install -g newman-reporter-htmlextra
      # Make directory for test results in workspace
      - name: Make Directory
        run: mkdir -p newman-results
      # Run newman cli
      - name: Run Newman
        env:
          POSTMAN_API_URL: 'https://api.getpostman.com'
          POSTMAN_API_KEY: ${{ secrets.POSTMAN_API_KEY }}
          POSTMAN_COLLECTION_UID: ${{ secrets.POSTMAN_COLLECTION_UID }}
        run: |
          newman run "${{env.POSTMAN_API_URL}}/collections/${{env.POSTMAN_COLLECTION_UID}}?apikey=${{env.POSTMAN_API_KEY}}" \
          -r htmlextra,cli --reporter-htmlextra-export newman-results/htmlreport.html
      # Upload test results to workspace
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: Postman_Test_Reports
          path: newman-results

Le code ci-dessus est un flux de travail simple qui s'exécute lorsque nous poussons vers le référentiel, en particulier sur la mainbranche par défaut. Nous définissons un travail pour les tests Postman avec une série d'étapes.

Tout d'abord, nous exécutons l'action de paiement, puis nous installons Node.js à l'aide d'une action prédéfinie actions/setup-node@v3. Ensuite, nous installons Newman et newman-reporter-htmlextra. Le reporter est un plugin pour Newman qui génère un résumé des tests au format HTML. Nous exécutons ensuite l'outil Newman CLI avec quelques arguments, y compris l'URL de l'API Postman pour notre collection.

Notez que nous avons défini certaines variables d'environnement. Les POSTMAN_API_KEYet POSTMAN_COLLECTION_UIDsont extraits des secrets de GitHub Action. Avant de définir ces secrets, nous devrons créer un référentiel. Enfin, après avoir exécuté Newman, nous utilisons l'action prédéfinie actions/upload-artifact@v3pour télécharger le fichier HTML généré par le rapporteur vers un emplacement auquel nous pourrons accéder ultérieurement.

Rassembler le tout

Enfin, nous devons pousser le projet vers GitHub et voir le workflow s'exécuter. Accédez à votre compte GitHub, créez un nouveau référentiel appelé delivery-apiet copiez l'URL distante. Ensuite, nous allons initialiser Git dans le projet, ajouter l'URL distante, valider nos modifications et pousser les modifications :

$ git init -b main
$ git remote add origin <your-remote-url>
$ git add .
$ git commit "<message>"
$ git push -u origin main

Si vous ouvrez l' Actionsonglet dans votre référentiel GitHub, vous devriez voir le workflow en cours d'exécution ou avoir échoué. C'est parce que nous n'avons pas ajouté les clés secrètes.

Pour résoudre ce problème, nous devons générer une clé API sur Postman et également récupérer l'UID de la collection. Accédez à votre espace de travail Postman ; dans la barre de menu supérieure, cliquez sur votre profil et sélectionnez Paramètres . Sélectionnez Clés API dans la navigation latérale, puis générez une clé API et copiez la valeur.

Ensuite, faites une GETdemande à l'URL https://api.getpostman.com/collectionset définissez un en-tête avec la clé x-api-keyet une valeur égale à la clé API que vous avez générée. Votre réponse doit contenir une liste de vos collections :

Obtenir les collections de réponses aux demandes

Accédez à votre référentiel GitHub et ajoutez le POSTMAN_API_KEYet POSTMAN_COLLECTION_UIDdans les secrets GitHub Action. Il POSTMAN_COLLECTION_UIDs'agit du uidchamp de votre Delivery-API Testsobjet de collection.

Clé de l'API Postman du référentiel Github

Maintenant, accédez à Actionsnouveau à votre onglet et essayez de réexécuter les tâches ayant échoué. Si tout a bien fonctionné, vous devriez voir un fichier dans le Artifactspanneau, qui est le rapport généré à partir du flux de travail. Vous pouvez télécharger et ouvrir le fichier HTML dans votre navigateur.

Fichier de rapports de test Postman terminé

Et c'est tout! Nous avons automatisé avec succès nos tests d'API. Chaque fois que nous apportons des modifications et que nous poussons vers la branche en amont, cela déclenche le flux de travail, exécutant nos tests. Idéalement, nous voulons exécuter ce flux de travail après qu'un déploiement a été effectué, mais pour rester simple, nous avons défini uniquement le flux de travail des tests Postman.

Limitations de Postman pour les tests d'API

Postman est un excellent outil pour les tests d'API, mais il a ses propres limites. Comme pour tout ce qui concerne les logiciels, vous voudrez prendre en compte les besoins uniques de votre projet pour déterminer le bon outil pour le travail. La première chose à considérer est la portée et la complexité de vos tests. Si vous devez écrire des tests qui dépendent d'un service externe, vous ne pourrez peut-être pas l'automatiser facilement.

Une autre limite est la flexibilité. Étant donné que vous écrivez des tests dans un environnement différent de celui où vit votre logique d'application, il est difficile de partager et de réutiliser des morceaux de code. Cela peut être particulièrement frustrant lorsque vous souhaitez tester un point de terminaison d'API par rapport à plusieurs paramètres de requête différents. Postman reste un excellent outil de test, et c'est à vous, en tant que développeur, de prendre des décisions éclairées quant à son utilisation pour les tests.

Conclusion

Dans cet article, nous avons examiné pourquoi il est important de tester les API dans votre application. Nous avons exploré le test de nos API à l'aide de Postman, y compris la configuration des actions Newman et GitHub. Enfin, nous avons passé en revue certaines des limitations de Postman pour les tests. Dans l'ensemble, Postman est un excellent outil pour créer, tester, documenter et se moquer des API. J'espère que vous avez apprécié ce tutoriel et bon codage !

Source : https://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

Comment Automatiser Les Tests D'API Avec Postman

Thai Son

1659785534

Cách Tự Động Hóa Các Bài Kiểm Tra API Với Postman

API là động lực đằng sau hầu như mọi ứng dụng bạn sẽ xây dựng với tư cách là nhà phát triển, đóng vai trò như một kênh giao tiếp giữa hai hoặc nhiều thành phần phần mềm.

Tuy nhiên, hệ quả của loại hệ thống này là sự hỏng hóc của một thành phần có thể gây ảnh hưởng đáng kể đến các thành phần khác phụ thuộc vào nó. Do đó, điều quan trọng là phải kiểm tra rộng rãi các API của bạn để đảm bảo tính chính xác và khả năng dự đoán của ứng dụng của bạn.

Có nhiều cách khác nhau để bạn có thể kiểm tra các API của mình và bất kỳ phương pháp hoặc kết hợp phương pháp nào bạn chọn cuối cùng sẽ phụ thuộc vào nhu cầu kinh doanh hiện tại, tài nguyên sẵn có và chi tiết triển khai của bạn.

Trong bài viết này, chúng ta sẽ khám phá cách viết các bài kiểm tra chức năng và tích hợp tự động cho các API của bạn sẽ chạy trong đường dẫn CI / CD.

Tại sao bạn nên tự động hóa các bài kiểm tra API của mình?

Các bài kiểm tra viết giúp đảm bảo khả năng dự đoán và tính đúng đắn của các ứng dụng của bạn tại bất kỳ thời điểm nào. Do đó, bạn nên chạy thử nghiệm thường xuyên khi codebase của bạn thay đổi. Các nhiệm vụ lặp đi lặp lại như thế này thường là ứng cử viên tốt cho tự động hóa.

Các bài kiểm tra tự động giúp bạn tự tin để thực hiện các thay đổi và thêm các tính năng mới vào ứng dụng của mình vì bạn luôn có thể dựa vào các bài kiểm tra của mình để chỉ ra các lỗi mà bạn có thể đã đưa vào.

Viết các bài kiểm tra API với Postman

Postman là một nền tảng cung cấp một bộ công cụ hoàn chỉnh để xây dựng, thử nghiệm, lập tài liệu và mô phỏng các API. Là một nhà phát triển, rất có thể bạn đã sử dụng Postman để đưa ra các yêu cầu đối với ứng dụng phụ trợ của mình trong khi phát triển cục bộ, nhưng bạn thậm chí có thể làm được nhiều hơn thế với nó.

Thiết lập Người đưa thư

Để làm theo hướng dẫn này, bạn cần có tài khoản Postman. Nếu bạn chưa có, hãy tạo một tài khoản miễn phí . Sau đó, điều hướng đến không gian làm việc Postman của bạn để bắt đầu.

Chúng tôi sẽ tạo một bộ sưu tập mới được gọi là Delivery-API Testsnơi chúng tôi sẽ viết một số thử nghiệm chức năng và tích hợp cho một API phân phối mà chúng tôi sẽ tạo sau trong phần này. Kiểm tra chức năng kiểm tra hành vi của một điểm cuối API và đảm bảo rằng chu trình yêu cầu-phản hồi tuân theo mong đợi. Mặt khác, kiểm tra tích hợp kiểm tra các luồng cụ thể có thể được tạo thành từ hai hoặc nhiều điểm cuối để xác định xem các thành phần khác nhau liên quan đến luồng người dùng có hoạt động như mong đợi hay không.

Tại thời điểm này, không gian làm việc của bạn sẽ hiển thị bộ sưu tập trong bảng điều khiển bên trái:

Bộ sưu tập không gian làm việc của Postman

Thiết lập các yêu cầu

Tiếp theo, chúng tôi sẽ cần tạo các yêu cầu sẽ giữ các thử nghiệm của chúng tôi. Một yêu cầu sẽ đại diện cho một điểm cuối API. Trên Delivery-API Testsbộ sưu tập, nhấp vào nút menu xuất hiện ở bên phải.

Chọn Thêm yêu cầu và đặt tên cho yêu cầu được tạo Search Deliveries. Tạo thêm ba yêu cầu có tên Select Delivery, Confirm Pickupvà Complete Delivery.

Bây giờ, chúng ta cần viết các bài kiểm tra cho mỗi yêu cầu. Postman có một công cụ kiểm tra tích hợp cho phép bạn viết các bài kiểm tra bằng cú pháp JavaScript. Kiểm tra được thực hiện ngay lập tức sau khi một yêu cầu được chạy và bạn có thể truy cập phản hồi được trả về từ yêu cầu trong tập lệnh kiểm tra.

Trong Delivery-API Testsbộ sưu tập, chọn Search Deliveriesyêu cầu và chọn tab Kiểm tra . Dán khối mã sau vào trình chỉnh sửa:

const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains results", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("array")
    pm.expect(responseJson.data[0]).to.haveOwnProperty("status")
})

pm.collectionVariables.set("SELECTED_DELIVERY_ID", responseJson.data[0].id)

Trong đoạn mã trên, chúng tôi nhận được phản hồi ở định dạng JSON bằng cách gọi pm.response.json(). Lưu ý rằng đó pmlà một đối tượng toàn cục có sẵn trong tất cả các tập lệnh yêu cầu. Sau đó, chúng tôi xác định hai trường hợp thử nghiệm bằng cách sử dụng pm.test.

Nếu bạn đã quen với việc thử nghiệm trong JavaScript , thì cú pháp ở đây phải đơn giản. Postman hỗ trợ cú pháp từ thư viện xác nhận Chai , vì vậy bạn có thể viết các bài kiểm tra theo cách giống như cách bạn đã làm trong JavaScript.

Trong các trường hợp thử nghiệm, chúng tôi đang kiểm tra mã trạng thái chính xác, loại dữ liệu được trả về và một số trường bắt buộc bổ sung. Đây là những bài kiểm tra đơn giản, nhưng mục đích là để hiểu khái niệm kiểm thử trong Postman.

Lưu ý rằng trong dòng cuối cùng của khối mã, chúng tôi đang đặt một biến tập hợp được gọi là SELECTED_DELIVERY_ID. Các biến tập hợp là một cách trực quan để chia sẻ dữ liệu qua các yêu cầu.

Tiếp theo, chúng tôi muốn viết các bài kiểm tra cho các yêu cầu khác. Dán các khối mã sau vào các yêu cầu tương ứng:

// Select Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("QUEUED")
})


// Confirm Pickup
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("PICKED_UP")
})


// Complete Delivery
const responseJson = pm.response.json()

pm.test("response status", function() {
    pm.response.to.have.status(200)
})

pm.test("data contains result", function() {
    pm.expect(responseJson).to.haveOwnProperty("data")
    pm.expect(responseJson.data).to.be.an("object")
    pm.expect(responseJson.data).to.haveOwnProperty("status")
    pm.expect(responseJson.data.status).to.eql("COMPLETED")
})

Các trường hợp thử nghiệm cho các yêu cầu khác giống hệt nhau ngoại trừ khẳng định trên statustrường. Bây giờ chúng tôi có các bài kiểm tra cho các yêu cầu của mình, hãy chạy chúng. Chúng tôi sẽ cần tạo một máy chủ phụ trợ sẽ xử lý các yêu cầu API. Bạn có thể triển khai máy chủ phụ trợ bằng bất kỳ ngôn ngữ hoặc khuôn khổ nào miễn là nó tuân thủ REST, nhưng trong bài viết này, chúng tôi sẽ xây dựng một máy chủ Node.js đơn giản bằng Koa .

Xây dựng máy chủ API

Trong thiết bị đầu cuối của bạn, hãy tạo một thư mục và khởi tạo một dự án Node.js bằng Yarn hoặc npm:

$ mkdir delivery-api
$ cd delivery-api
$ yarn init -y

Bây giờ, hãy tạo một tệp có tên app.jsvà cài đặt các phụ thuộc cần thiết:

$ touch app.js
$ yarn add koa @koa/router

Trong package.jsontệp của bạn, hãy thêm tập lệnh sau:

//...
  "scripts": {
    "start": "node app.js"
  },
//...

Koa là một khung phần mềm trung gian HTTP nhẹ cho Node.js tương tự như Express. Hãy khởi tạo một máy chủ Koa và xác định các trình xử lý tuyến đường tương ứng với các yêu cầu mà chúng tôi thiết lập trong Postman. Trong app.jstệp của bạn, hãy dán khối mã bên dưới:

const Koa = require("koa");
const Router = require("@koa/router");
const app = new Koa();
const router = new Router();

app.use(router.routes());

const deliveries = [
   {
      id: "1",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148928000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148928000",
      instructions: "",
      status: "CREATED",
   },
   {
      id: "2",
      pickupAddress: "1000 4th Ave, Seattle, WA, 98104",
      pickupPhoneNumber: "+14148915000",
      dropoffAddress: "1201 3rd Ave, Seattle, WA, 98101",
      dropoffPhoneNumber: "+14148915000",
      instructions: "",
      status: "CREATED",
   },
];

router.get("/deliveries", (ctx) => {
   ctx.body = {
      status: "00",
      message: "successs",
      data: deliveries,
   };
});

router.get("/deliveries/:id/select", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "QUEUED" },
   };
});

router.get("/deliveries/:id/confirm-pickup", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "PICKED_UP" },
   };
});

router.get("/deliveries/:id/complete", (ctx) => {
   const id = ctx.params["id"];
   const delivery = deliveries.find((obj) => obj.id === id);
   if (!delivery) {
      ctx.body = {
         status: "01",
         message: "not found",
         data: null,
      };
   }
   ctx.body = {
      status: "00",
      message: "successs",
      data: { ...delivery, status: "COMPLETED" },
   };
});

app.listen(8000);

Có rất nhiều điều đang diễn ra ở đây, vì vậy hãy chia nhỏ nó ra. Đầu tiên, chúng tôi khởi tạo một ứng dụng Koa mới và một Routerđối tượng mới. Sử dụng routerví dụ, chúng tôi xác định bốn tuyến đường với các đường dẫn phù hợp với các yêu cầu mà chúng tôi đã tạo trong Postman. Cuối cùng, chúng tôi khởi động máy chủ bằng cách gọi app.listen().

Tóm lại, máy chủ API đơn giản này đang cố gắng mô phỏng quá trình phân phối đơn đặt hàng cho một ứng dụng giao đồ ăn. Bây giờ, khởi động máy chủ bằng cách chạy yarn starttrong thiết bị đầu cuối của bạn.

Chạy thử nghiệm thủ công trên Postman

Bây giờ, chúng tôi đã thiết lập mọi thứ để chạy thử nghiệm. Nếu bạn đang sử dụng Postman trên web, bạn sẽ không thể kết nối với localhost. Tuy nhiên, có hai cách để giải quyết vấn đề này. Bạn có thể tải xuống ứng dụng Postman dành cho máy tính để bàn hoặc sử dụng ngrok làm đường hầm để hiển thị localhostcổng của bạn với internet.

Nếu bạn quyết định sử dụng ngrok, tất cả những gì bạn cần làm là cài đặt nó và bắt đầu một đường hầm trỏ đến máy chủ của bạn. Mở một phiên bản đầu cuối khác, sau đó chạy lệnh sau và sao chép URL được hiển thị:

$ ngrok http 8000

URL phải tương tự như https://3d43-154-130-109-210.ngrok.io. Điều hướng đến Người đưa thư, trên web hoặc máy tính để bàn, chọn Delivery-API Testsbộ sưu tập và mở tab biến .

Thêm một biến bằng API_BASE_URLkhóa và đặt giá trị thành http://localhost:8000hoặc ngrok URL nếu bạn không sử dụng máy tính để bàn Postman. Đảm bảo nhấp vào Persist All khi thêm một biến mới để đảm bảo rằng các dịch vụ bên ngoài có thể truy cập vào nó:

Kiểm tra API phân phối biến của người đưa thư

Bây giờ, chúng ta có thể sử dụng biến bộ sưu tập cho mỗi yêu cầu. Cập nhật trường URL cho mỗi yêu cầu thành các giá trị sau:

Search Deliveries:{{API_BASE_URL}}/deliveries?page=1&count=20
Select Delivery:{{API_BASE_URL}}/deliveries/:id/select
Confirm Pickup:{{API_BASE_URL}}/deliveries/:id/confirm-pickup
Complete Delivery:{{API_BASE_URL}}/deliveries/:id/complete

Chúng tôi có thể chạy thử nghiệm của mình theo cách thủ công bằng một trong hai phương pháp. Đầu tiên là chạy các yêu cầu riêng lẻ, cho phép thực thi tập lệnh thử nghiệm cho từng yêu cầu. Ngoài ra, chúng ta có thể chạy bộ sưu tập cùng một lúc bằng cách sử dụng bộ chạy bộ sưu tập. Chúng tôi sẽ sử dụng trình chạy bộ sưu tập trong phần tiếp theo, nhưng bạn có thể tạm thời chạy từng yêu cầu theo cách thủ công bằng cách nhấp vào nút Gửi .

Khi bạn chạy một yêu cầu, bạn sẽ thấy phản hồi trong bảng điều khiển dưới cùng, nhưng bạn cũng có thể xem kết quả kiểm tra bằng cách nhấp vào tab Kết quả kiểm tra trong bảng điều khiển dưới cùng:

Tab Kết quả Kiểm tra Người đưa thư

Đó là tất cả những gì bạn cần làm để chạy thử nghiệm trong Postman. Tuy nhiên, bạn sẽ cảm thấy không dễ dàng khi truy cập không gian làm việc Postman của bạn và chạy thử nghiệm bất cứ khi nào bạn thực hiện các thay đổi đối với cơ sở mã của mình. Cách tiếp cận này không phù hợp với quy trình phát triển, vì vậy hãy cải thiện nó.

Tự động hóa các bài kiểm tra API của bạn

Trong phần này, chúng tôi sẽ làm cho quy trình thử nghiệm trực quan hơn và ít tốn thời gian hơn bằng cách tự động hóa quy trình làm việc. Quy trình phát triển được tối ưu hóa liên quan đến việc thực hiện các thay đổi cục bộ và đẩy các tính năng mới sang kiểm soát nguồn, nơi chúng được chọn bởi đường ống CI / CD, kích hoạt một số nhiệm vụ xây dựng hoặc triển khai.

Postman cung cấp một công cụ dòng lệnh được gọi là Newman cho phép bạn chạy các bộ sưu tập từ CLI. Nó cũng cung cấp khả năng tích hợp liền mạch với các môi trường CI / CD, có nghĩa là chúng ta có thể thiết lập các bài kiểm tra của mình để chạy trong một bước triển khai. Điều này giúp đơn giản hóa đáng kể quá trình thử nghiệm, giúp chúng tôi không phải liên tục chạy thử nghiệm trong không gian làm việc.

Tích hợp Newman với GitHub Actions

Chúng tôi có thể thiết lập Newman trong nhiều dịch vụ tích hợp liên tục. Trong bài viết này, chúng tôi sẽ sử dụng GitHub Actions. Hãy bắt đầu bằng cách xác định quy trình làm việc cho Newman. Trong delivery-apidự án của bạn, hãy chạy các lệnh sau:

$ mkdir .github
$ mkdir .github/workflows
$ touch .github/workflows/postman-tests.yml

Thêm định nghĩa dòng công việc sau vào postman-tests.ymltệp:

# postman-tests.yml
name: Newman Run
on:
  push:
    branches:
      - main
  # types: [closed]
jobs:
  newman:
    name: Postman-tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v2
      - name: Install Node
        uses: actions/setup-node@v3
        with:
          node-version: 14
      - name: Install Newman & Reporter
        run: |
          npm install -g newman
          npm install -g newman-reporter-htmlextra
      # Make directory for test results in workspace
      - name: Make Directory
        run: mkdir -p newman-results
      # Run newman cli
      - name: Run Newman
        env:
          POSTMAN_API_URL: 'https://api.getpostman.com'
          POSTMAN_API_KEY: ${{ secrets.POSTMAN_API_KEY }}
          POSTMAN_COLLECTION_UID: ${{ secrets.POSTMAN_COLLECTION_UID }}
        run: |
          newman run "${{env.POSTMAN_API_URL}}/collections/${{env.POSTMAN_COLLECTION_UID}}?apikey=${{env.POSTMAN_API_KEY}}" \
          -r htmlextra,cli --reporter-htmlextra-export newman-results/htmlreport.html
      # Upload test results to workspace
      - name: Upload Results
        uses: actions/upload-artifact@v3
        with:
          name: Postman_Test_Reports
          path: newman-results

Đoạn mã trên là một dòng công việc đơn giản chạy khi chúng tôi đẩy đến kho lưu trữ, cụ thể là trên mainnhánh mặc định. Chúng tôi xác định một công việc cho các bài kiểm tra Người đưa thư với một loạt các bước.

Đầu tiên, chúng tôi chạy hành động thanh toán, sau đó chúng tôi cài đặt Node.js bằng một hành động được xác định trước actions/setup-node@v3. Tiếp theo, chúng tôi cài đặt Newman và newman-reporter-htmlextra. Trình báo cáo là một plugin cho Newman tạo ra một bản tóm tắt các bài kiểm tra ở định dạng HTML. Sau đó, chúng tôi chạy công cụ Newman CLI với một số đối số, bao gồm URL API Postman cho bộ sưu tập của chúng tôi.

Lưu ý rằng chúng tôi đã xác định một số biến môi trường. Đã và đang được POSTMAN_API_KEYlấy POSTMAN_COLLECTION_UIDtừ bí mật Hành động GitHub. Trước khi thiết lập những bí mật này, chúng tôi sẽ cần tạo một kho lưu trữ. Cuối cùng, sau khi chạy Newman, chúng tôi sử dụng hành động được xác định trước actions/upload-artifact@v3để tải tệp HTML do người báo cáo tạo ra đến vị trí mà chúng tôi có thể truy cập sau này.

Mang tất cả lại với nhau

Cuối cùng, chúng ta cần đẩy dự án lên GitHub và xem quy trình làm việc chạy. Điều hướng đến tài khoản GitHub của bạn, tạo một kho lưu trữ mới có tên delivery-apivà sao chép URL từ xa. Tiếp theo, chúng tôi sẽ khởi tạo Git trong dự án, thêm URL từ xa, cam kết các thay đổi của chúng tôi và đẩy các thay đổi:

$ git init -b main
$ git remote add origin <your-remote-url>
$ git add .
$ git commit "<message>"
$ git push -u origin main

Nếu bạn mở Actionstab trong kho lưu trữ GitHub của mình, bạn sẽ thấy dòng công việc đang chạy hoặc bị lỗi. Điều này là do chúng tôi chưa thêm khóa bí mật.

Để giải quyết vấn đề này, chúng tôi cần tạo khóa API trên Postman và cũng tìm nạp UID bộ sưu tập. Điều hướng đến không gian làm việc Postman của bạn; ở thanh menu trên cùng, nhấp vào hồ sơ của bạn và chọn Cài đặt . Chọn Khóa API từ điều hướng bên, sau đó tạo khóa API và sao chép giá trị.

Tiếp theo, thực hiện GETyêu cầu đối với URL https://api.getpostman.com/collectionsvà đặt tiêu đề có khóa x-api-keyvà giá trị bằng khóa API mà bạn đã tạo. Phản hồi của bạn phải chứa danh sách các bộ sưu tập của bạn:

Nhận bộ sưu tập phản hồi yêu cầu

Truy cập kho lưu trữ GitHub của bạn và thêm POSTMAN_API_KEYvà POSTMAN_COLLECTION_UIDtrong các bí mật Hành động GitHub. Đây POSTMAN_COLLECTION_UIDlà uidtrường trong Delivery-API Testsđối tượng bộ sưu tập của bạn.

Kho lưu trữ Github Postman API Keyy

Bây giờ, hãy truy cập lại Actionstab của bạn và thử chạy lại các công việc bị lỗi. Nếu mọi thứ hoạt động tốt, bạn sẽ thấy một tệp trong Artifactsbảng, đó là báo cáo được tạo từ quy trình làm việc. Bạn có thể tải xuống và mở tệp HTML trong trình duyệt của mình.

Tệp báo cáo kiểm tra người đưa thư đã hoàn thành

Và đó là nó! Chúng tôi đã tự động hóa thành công các thử nghiệm API của mình. Mỗi khi chúng tôi thực hiện thay đổi và đẩy lên nhánh ngược dòng, nó sẽ kích hoạt quy trình làm việc, chạy các thử nghiệm của chúng tôi. Lý tưởng nhất là chúng tôi muốn chạy dòng công việc này sau khi triển khai đã được thực hiện, nhưng để giữ cho nó đơn giản, chúng tôi chỉ xác định dòng công việc của Postman tests.

Hạn chế của Postman đối với thử nghiệm API

Postman là một công cụ tuyệt vời để kiểm tra API, tuy nhiên nó có những hạn chế riêng. Giống như mọi thứ khác trong phần mềm, bạn sẽ muốn xem xét nhu cầu của dự án độc đáo của mình để xác định công cụ phù hợp cho công việc. Điều đầu tiên cần xem xét là phạm vi và độ phức tạp của các bài kiểm tra của bạn. Nếu bạn cần viết các bài kiểm tra phụ thuộc vào một số dịch vụ bên ngoài, bạn có thể không dễ dàng tự động hóa việc đó.

Một hạn chế khác là tính linh hoạt. Vì bạn đang viết các bài kiểm tra trong một môi trường khác với nơi logic ứng dụng của bạn sống, nên rất khó để chia sẻ và sử dụng lại các đoạn mã. Điều này có thể đặc biệt khó chịu khi bạn muốn kiểm tra một điểm cuối API với nhiều tham số yêu cầu khác nhau. Postman vẫn là một công cụ tuyệt vời để thử nghiệm và nhà phát triển sẽ tùy thuộc vào bạn để đưa ra quyết định sáng suốt về việc sử dụng nó để thử nghiệm.

Sự kết luận

Trong bài viết này, chúng tôi đã xem xét lý do tại sao việc kiểm tra các API trong ứng dụng của bạn lại quan trọng. Chúng tôi đã khám phá thử nghiệm các API của mình bằng Postman, bao gồm thiết lập Newman và GitHub Actions. Cuối cùng, chúng tôi đã xem xét một số hạn chế của Postman để thử nghiệm. Nhìn chung Postman là một công cụ tuyệt vời để xây dựng, thử nghiệm, lập tài liệu và chế biến các API. Tôi hy vọng bạn thích hướng dẫn này và viết mã vui vẻ!

Nguồn: https://blog.logrocket.com/how-automate-api-tests-postman/

#api #postman

Cách Tự Động Hóa Các Bài Kiểm Tra API Với Postman