1674577278
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.
1670653518
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?
#postman #testing
1665372648
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:
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
Are there any course requirements or prerequisites?
Who this course is for:
#api #testing #softwaretesting #postman
1664954189
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
Are there any course requirements or prerequisites?
Who this course is for:
#postman #api #testing
1659961080
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
Máy chủ gRPC của chúng tôi có
2 loại tin nhắn
1 dịch vụ
4 RPC trong Dịch vụ đó
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
- 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 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.
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.
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.
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.
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 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
1659953836
Мы можем использовать Postman для запросов gRPC. (Во время написания этой статьи она находится на стадии БЕТА.)
В этой статье мы собираемся использовать инструмент Postman (в качестве клиента gRPC) для тестирования нашего API gRPC. Я собираюсь использовать простой сервер gRPC, который я разработал во время написания этой статьи .
В конце этой статьи вы сможете протестировать любые методы gRPC Server.
Запустите сервер gRPC
Наш сервер gRPC имеет
2 типа сообщений
1 услуга
4 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-клиент
— путем импорта прото-файла
— использование отражения сервера (для этого наш Сервер должен иметь отражение сервера в качестве дополнительного расширения, чтобы помочь клиентам в построении запросов во время выполнения без предварительной компиляции информации-заглушки в клиенте.)
— с помощью API-интерфейсов Protobuf, созданных в рабочей области Postman. (также вы можете импортировать файл прототипа, а затем создать API с импортированным прототипом.)
Мы выберем 1-й вариант, а затем создадим API. (Создание API будет выполнено почтальоном после того, как вы импортируете прото-файл)
Нажмите «Импортировать как API » .
Теперь мы готовы с нашим определением сервера в почтальоне, импортировав наш прото-файл.
Теперь нажмите « Выбрать метод », чтобы выбрать наш метод gRPC для вызова.
На данный момент Почтальон знает о нашем сервере, поэтому RPC, определенные на нашем сервере, будут доступны в раскрывающемся списке.
При отправке запроса вы можете авторизовать запрос с помощью виджета Авторизация , если это необходимо. Также вы можете отправить некоторые метаданные , если это необходимо.
Выберите метод
Выберите метод RPCRequest , который является унарным RPC нашего сервера, и просто нажмите кнопку Invoke, чтобы вызвать RPC, и мы получили наш ответ.
пустой запрос с ответом
Почтальон знает о нашем сервере, поэтому у него есть возможность генерировать пример сообщения .
Нажмите « Создать сообщение Exmaple» в нижней части виджета сообщений и вызовите RPC.
Генерация сообщений и получение ответа
Вау! мы получили свой ответ.
Теперь мы попробуем Client Streaming RPC в Postman.
После того, как вы выберете метод потоковой передачи клиента в разделе « Выбрать метод», Postman откроет виджет для отправки нашего потока запросов.
Ручей
Теперь нажмите « Создать пример сообщения » , чтобы сгенерировать сообщение или составить сообщение, и нажмите « Отправить » .
отправить потоковое сообщение
Повторите этот шаг столько раз, сколько хотите. Так как это клиентский потоковый RPC. Когда вы закончите с потоком сообщений, нажмите « Завершить потоковую передачу».
И Вы получите ответ обратно.
Ответ клиента на потоковую передачу
Мы получили наш ответ.
Теперь выберите метод ServerStreaming и вызовите RPC с нашим сообщением. Мы получим наши потоковые ответы.
Потоковая передача сервера
Мы получили ответы Stream.
Выберите метод StreamingBiDirectional и вызовите RPC для проверки двунаправленной потоковой передачи.
Как только я отправил запрос, я получил ответ на этот запрос (так реализован сервер)
отправлять и получать
После отправки запроса и получения ответа завершите поток.
Двунаправленная потоковая передача
Вы можете сохранять запросы в коллекции Postman , как обычно.
API, который мы создали, импортировав наш прото-файл, можно использовать повторно.
Резюме
Теперь вы знаете, как использовать Postman в качестве клиента gRPC .
Ссылка: https://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4
#postman #grpc #go
1659946588
我們可以將 Postman 用於 gRPC 請求。(在撰寫本文時,它處於 BETA 階段。)
在本文中,我們將使用 Postman 工具(作為 gRPC 客戶端)來測試我們的 gRPC API。我將使用我在撰寫本文時開發的簡單 gRPC 服務器。
您應該能夠在本文結尾處測試任何 gRPC 服務器方法。
啟動 gRPC 服務器
我們的 gRPC 服務器有
2 消息類型
1 服務
該服務中的 4 個 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 客戶端
— 通過導入 proto 文件
— 使用服務器反射(為此,我們的服務器需要將服務器反射作為可選擴展來幫助客戶端在運行時構建請求,而無需將存根信息預編譯到客戶端中。)
— 通過使用在 Postman 工作區中創建的 Protobuf API。(您也可以導入 proto 文件,然後使用導入的 proto 創建 API。)
我們將使用第一個選項,然後創建 API。(導入 proto 文件後,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中。
我們通過導入 proto 文件創建的 API 可以重複使用
概括
現在您已經了解瞭如何將 Postman 用作gRPC 客戶端。
鏈接:https ://faun.pub/test-and-debug-your-grpc-request-postman-9d97a42826b4
#postman #grpc #go
1659939360
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
Notre serveur gRPC a
2 types de messages
1 Prestation
4 RPC dans ce service
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
— 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 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.
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.
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.
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.
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.
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
1659932042
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
1659850740
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/
1659793080
API は、開発者が構築する事実上すべてのアプリケーションの原動力であり、2 つ以上のソフトウェア コンポーネント間の通信チャネルとして機能します。
ただし、このタイプのシステムの結果として、1 つのコンポーネントの障害が、それに依存する他のコンポーネントに大きな影響を与える可能性があります。したがって、API を広範囲にテストして、アプリケーションの正確性と予測可能性を確認することが重要です。
API をテストするにはさまざまな方法があります。選択する方法または方法の組み合わせは、最終的には現在のビジネス ニーズ、利用可能なリソース、および実装の詳細によって異なります。
この記事では、CI/CD パイプラインで実行される API の自動化された機能テストと統合テストを作成する方法について説明します。
テストを作成すると、いつでもアプリケーションの予測可能性と正確性を確保できます。したがって、コードベースが変更されるたびにテストを実行する必要があります。このような反復的なタスクは、多くの場合、自動化に適しています。
自動化されたテストは、導入した可能性のあるバグを指摘するために常にテストに頼ることができるため、自信を持ってアプリケーションに変更を加えたり、新しい機能を追加したりできます。
Postmanは、API の構築、テスト、文書化、およびモック化のための完全なツール セットを提供するプラットフォームです。開発者として、 Postman を使用してローカルで開発しているときにバックエンド アプリケーションにリクエストを送信したことがあると思いますが、Postman を使用してさらに多くのことができます。
このチュートリアルを進めるには、Postman アカウントが必要です。まだお持ちでない場合は、無料のアカウントを作成してください。次に、Postman ワークスペースに移動して開始します。
という名前の新しいコレクションをDelivery-API Tests
作成し、このセクションで後で作成する配信 API の機能テストと統合テストを記述します。機能テストでは、単一の API エンドポイントの動作をチェックし、要求と応答のサイクルが期待どおりであることを確認します。一方、統合テストでは、2 つ以上のエンドポイントで構成される特定のフローをチェックして、ユーザー フローに含まれるさまざまなコンポーネントが期待どおりに機能するかどうかを判断します。
この時点で、ワークスペースの左側のパネルにコレクションが表示されます。
次に、テストを保持するリクエストを作成する必要があります。リクエストは 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 サーバーを構築します。
ターミナルでフォルダーを作成し、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
します。
これで、テストを実行するためのすべての設定が完了しました。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_URL
Postman デスクトップを使用していない場合は、キーを含む変数を追加し、値をhttp://localhost:8000
ngrok URL に設定します。新しい変数を追加するときは、必ず [ Persist All ] をクリックして、外部サービスがアクセスできるようにしてください。
これで、リクエストごとにコレクション変数を使用できるようになりました。各リクエストの 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 ワークスペースにアクセスしてテストを実行するのは直感的ではありません。このアプローチは開発ワークフローと一致しないため、改善しましょう。
このセクションでは、ワークフローを自動化することで、テスト プロセスをより直感的にし、時間を節約します。最適化された開発ワークフローには、ローカルで変更を加え、新しい機能をソース管理にプッシュすることが含まれます。これらの機能は CI/CD パイプラインによって取得され、ビルドまたはデプロイ タスクがトリガーされます。
Postman には、CLI からコレクションを実行できるNewman というコマンド ライン ツールが用意されています。また、CI/CD 環境とのシームレスな統合も提供します。つまり、展開ステップ中に実行するテストをセットアップできます。これにより、テスト プロセスが大幅に簡素化され、ワークスペースで常にテストを実行する必要がなくなります。
多くの継続的インテグレーション サービスで 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 キーを生成して値をコピーします。
次に、GET
URL にリクエストを送信し、キーと生成した API キーと等しい値をhttps://api.getpostman.com/collections
ヘッダーに設定します。x-api-key
応答には、コレクションのリストが含まれている必要があります。
GitHub リポジトリに移動し、GitHub アクション シークレットにPOSTMAN_API_KEY
とを追加します。POSTMAN_COLLECTION_UID
は、コレクション オブジェクトPOSTMAN_COLLECTION_UID
のuid
フィールドです。Delivery-API Tests
ここで、Actions
もう一度タブに移動して、失敗したジョブを再実行してみてください。すべてが正常に機能していればArtifacts
、ワークフローから生成されたレポートであるファイルがパネルに表示されます。HTML ファイルをダウンロードして、ブラウザで開くことができます。
以上です!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/
1659792970
API 是您作为开发人员构建的几乎每个应用程序的驱动力,充当两个或多个软件组件之间的通信渠道。
但是,这种类型的系统的后果是一个组件的故障可能会对依赖它的其他组件产生重大影响。因此,广泛测试您的 API 以确保应用程序的正确性和可预测性至关重要。
有许多不同的方法可以测试您的 API,您选择的任何方法或方法组合最终将取决于您当前的业务需求、可用资源和实施细节。
在本文中,我们将探讨如何为将在 CI/CD 管道中运行的 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 服务器。
在您的终端中,创建一个文件夹并使用 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,您将无法连接到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以确保外部服务可以访问它:
现在,我们可以为每个请求使用集合变量。将每个请求的 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 工作区并运行测试都感觉不直观。这种方法与开发工作流程不一致,所以让我们对其进行改进。
在本节中,我们将通过自动化工作流程使测试过程更直观、更省时。优化的开发工作流程涉及进行本地更改并将新功能推送到源代码控制,在那里它们被 CI/CD 管道拾取,触发一些构建或部署任务。
Postman 提供了一个名为 Newman 的命令行工具,可让您从 CLI 运行集合。它还提供与 CI/CD 环境的无缝集成,这意味着我们可以将测试设置为在部署步骤中运行。这极大地简化了测试过程,使我们不必经常在工作区中运行测试。
我们可以在许多持续集成服务中设置纽曼。在本文中,我们将使用 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@v3
Node.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
现在,再次转到您的Actions
选项卡并尝试重新运行失败的作业。如果一切正常,您应该会在Artifacts
面板中看到一个文件,该文件是工作流生成的报告。您可以在浏览器中下载并打开 HTML 文件。
就是这样!我们已经成功地自动化了我们的 API 测试。每次我们进行更改并推送到上游分支时,它都会触发工作流,运行我们的测试。理想情况下,我们希望在部署完成后运行这个工作流,但为了简单起见,我们只定义了 Postman 测试的工作流。
Postman 是一个很棒的 API 测试工具,但它也有其自身的局限性。与软件中的其他所有内容一样,您需要考虑您独特的项目需求来确定适合该工作的工具。首先要考虑的是测试的范围和复杂性。如果您需要编写依赖于某些外部服务的测试,您可能无法轻松实现自动化。
另一个限制是灵活性。因为您在与应用程序逻辑所在的环境不同的环境中编写测试,所以很难共享和重用代码片段。当您想要针对多个不同的请求参数测试 API 端点时,这尤其令人沮丧。Postman 仍然是一个很好的测试工具,作为开发人员,您可以就使用它进行测试做出明智的决定。
在本文中,我们回顾了为什么在您的应用程序中测试 API 很重要。我们探索了使用 Postman 测试我们的 API,包括设置 Newman 和 GitHub Actions。最后,我们回顾了 Postman 的一些测试限制。总体而言,Postman 是构建、测试、记录和模拟 API 的绝佳工具。我希望您喜欢本教程,并祝您编码愉快!
来源:https ://blog.logrocket.com/how-automate-api-tests-postman/
1659789193
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.
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.
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.
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 Tests
donde 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:
A continuación, necesitaremos crear solicitudes que contengan nuestras pruebas. Una solicitud representará un punto final de API. En la Delivery-API Tests
colecció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 Pickup
y 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 Tests
colección, seleccione la Search Deliveries
solicitud 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 pm
es 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 status
campo. 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 .
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.js
e instala las dependencias necesarias:
$ touch app.js
$ yarn add koa @koa/router
En su package.json
archivo, 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.js
archivo, 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 Router
objeto. Usando la router
instancia, 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 start
en su terminal.
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 localhost
puerto 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 Tests
colección y abra la pestaña de variables .
Agregue una variable con la API_BASE_URL
clave y establezca el valor en http://localhost:8000
o 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:
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:
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.
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.
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-api
proyecto, 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.yml
archivo:
# 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 main
rama 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_KEY
y POSTMAN_COLLECTION_UID
se 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@v3
para cargar el archivo HTML generado por el reportero en una ubicación a la que podamos acceder más adelante.
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-api
y 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 Actions
pestañ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 GET
solicitud a la URL https://api.getpostman.com/collections
y establezca un encabezado con la clave x-api-key
y un valor igual a la clave API que generó. Su respuesta debe contener una lista de sus colecciones:
Vaya a su repositorio de GitHub y agregue POSTMAN_API_KEY
y POSTMAN_COLLECTION_UID
en los secretos de GitHub Action. El POSTMAN_COLLECTION_UID
es el uid
campo en su Delivery-API Tests
objeto de colección.
Ahora, vaya a su Actions
pestaña nuevamente e intente volver a ejecutar los trabajos fallidos. Si todo funcionó bien, debería ver un archivo en el Artifacts
panel, que es el informe generado del flujo de trabajo. Puede descargar y abrir el archivo HTML en su navegador.
¡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.
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.
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/
1659789000
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.
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.
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.
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 Tests
où 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 :
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 Tests
collection, 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 Pickup
et 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 Tests
collection, sélectionnez la Search Deliveries
requê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 pm
s'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 status
champ. 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 .
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.js
et installez les dépendances nécessaires :
$ touch app.js
$ yarn add koa @koa/router
Dans votre package.json
fichier, 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.js
fichier, 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 Router
objet. À l'aide de l' router
instance, 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 start
dans votre terminal.
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 localhost
port à 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 Tests
collection et ouvrez l' onglet des variables .
Ajoutez une variable avec la API_BASE_URL
clé et définissez la valeur sur http://localhost:8000
ou 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 :
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 :
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.
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.
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-api
projet, 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.yml
fichier :
# 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 main
branche 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_KEY
et POSTMAN_COLLECTION_UID
sont 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@v3
pour télécharger le fichier HTML généré par le rapporteur vers un emplacement auquel nous pourrons accéder ultérieurement.
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-api
et 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' Actions
onglet 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 GET
demande à l'URL https://api.getpostman.com/collections
et définissez un en-tête avec la clé x-api-key
et une valeur égale à la clé API que vous avez générée. Votre réponse doit contenir une liste de vos collections :
Accédez à votre référentiel GitHub et ajoutez le POSTMAN_API_KEY
et POSTMAN_COLLECTION_UID
dans les secrets GitHub Action. Il POSTMAN_COLLECTION_UID
s'agit du uid
champ de votre Delivery-API Tests
objet de collection.
Maintenant, accédez à Actions
nouveau à 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 Artifacts
panneau, 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.
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.
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.
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/
1659785534
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.
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.
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ó.
Để 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 Tests
nơ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:
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 Tests
bộ 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 Pickup
và 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 Tests
bộ sưu tập, chọn Search Deliveries
yê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 đó pm
là 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 status
trườ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 .
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.js
và cài đặt các phụ thuộc cần thiết:
$ touch app.js
$ yarn add koa @koa/router
Trong package.json
tệ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.js
tệ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 router
ví 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 start
trong thiết bị đầu cuối của bạn.
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ị localhost
cổ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 Tests
bộ sưu tập và mở tab biến .
Thêm một biến bằng API_BASE_URL
khóa và đặt giá trị thành http://localhost:8000
hoặ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ó:
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:
Đó 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ó.
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.
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-api
dự á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.yml
tệ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 main
nhá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_KEY
lấy POSTMAN_COLLECTION_UID
từ 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.
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-api
và 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ở Actions
tab 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 GET
yêu cầu đối với URL https://api.getpostman.com/collections
và đặt tiêu đề có khóa x-api-key
và 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:
Truy cập kho lưu trữ GitHub của bạn và thêm POSTMAN_API_KEY
và POSTMAN_COLLECTION_UID
trong các bí mật Hành động GitHub. Đây POSTMAN_COLLECTION_UID
là uid
trường trong Delivery-API Tests
đối tượng bộ sưu tập của bạn.
Bây giờ, hãy truy cập lại Actions
tab 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 Artifacts
bả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.
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.
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.
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/