11. API Testing Using Postman

An API (Application Programming Interface) allows different software systems to communicate with each other. In QA, we primarily test REST APIs which follow the HTTP protocol and return data in JSON or XML format.

An API is a set of rules that lets one software application communicate with another. This is crucial in software development since different applications often need to exchange data and functionalities. For instance, when you use an app to check the weather, that app communicates with a weather service API to fetch current weather conditions. In the Quality Assurance (QA) phase, the focus is mainly on testing REST APIs, which utilize the HTTP protocol—a foundation of the web. These APIs often return data in either JSON (JavaScript Object Notation) or XML (eXtensible Markup Language). JSON is more common today due to its simplicity and ease of use in JavaScript environments.

Think of an API like a waiter in a restaurant. When you place an order, you're communicating your needs (like the dish you want) to the waiter (the API). The waiter takes your request to the kitchen (the server) and brings back your food (the data). Just as the waiter helps you communicate with the kitchen, an API helps different software systems communicate with each other.

🔹 REST (Representational State Transfer) is: ● Stateless: Each call is independent ● Resource-Based: Uses URLs to identify resources ● Uses HTTP methods: GET, POST, PUT, DELETE

REST, which stands for Representational State Transfer, outlines a set of principles for designing networked applications. A key characteristic of REST APIs is that they are stateless, meaning that each request from a client to the server must contain all the information the server needs to fulfill that request. This leads to greater scalability as the server doesn’t need to remember previous interactions. Resources in REST are represented by URLs, which act as unique identifiers for these resources. RESTful API operations are typically performed using standard HTTP methods, such as GET for retrieving data, POST for creating new resources, PUT for updating existing resources, and DELETE for removing resources.

Imagine browsing a library. Each book (resource) has its unique location (URL). When you want a book (GET), you go directly to its location. If you want to place a new book on the shelf (POST), you simply take it and put it there without needing to inform the librarian of previous requests. Each transaction (request) stands alone, which mirrors the stateless nature of REST.

Postman is a GUI tool used to send HTTP requests to APIs and analyze responses. 🔹 Key Areas of Postman Interface: ● Request Builder: Where you choose the HTTP method and enter the API URL ● Headers Tab: Set request headers (e.g., Content-Type: application/json) ● Body Tab: Provide data for POST, PUT methods (usually JSON) ● Params Tab: Add query parameters ● Send Button: Execute the request ● Response Viewer: View status code, response body, headers, and time

Postman is a widely used graphical user interface (GUI) tool that assists developers and testers in interacting with APIs without needing extensive programming knowledge. The main components of Postman's interface include the Request Builder, where you specify the type of HTTP request (like GET or POST) and the API's URL. The Headers Tab allows you to configure important request headers, such as the format of the data being sent. The Body Tab is where you input data for methods like POST and PUT, often in JSON format. Params Tab is for query parameters that can be included in the API request, while the Send Button lets you execute the request. Finally, the Response Viewer displays important information about the response you get back from the server, such as the status code and data returned.

Think of Postman like a remote control for your TV. The buttons on the remote allow you to change channels (method), adjust volume (headers), and navigate menus (body data), all to interact with your TV (API) smoothly. You press buttons to get the results you want, similar to how you send requests to an API through Postman and receive responses.

1. Select GET
2. Enter URL: https://api.example.com/users
3. Click Send
4. View response: [ { "id": 1, "name": "Alice" }, { "id": 2, "name": "Bob" } ]

In this example, we're sending a GET request to an API that retrieves a list of users. We start by selecting the GET method, indicating that we want to retrieve data. After that, we enter the specific URL that points to the resource we want to access—in this case, the user list. Once everything is set, we click the Send button, which dispatches our request to the server. The server responds with data, typically in JSON format, which is displayed on the screen. In this case, we see a list containing two users, each represented by their unique ID and name.

Think of it like ordering books from a library's online catalog. You specify what you want (the GET request), the librarian checks their stock (the server), and returns the list of available books (the JSON response). If you requested users, they appear right there in front of you!

1. Select POST
2. Enter URL: https://api.example.com/users
3. Go to Body > raw > JSON
4. Enter: { "name": "Charlie", "email": "charlie@example.com" }
5. Click Send

Here, we illustrate how to create a new user by sending a POST request. First, we select the POST method, indicating that we want to send data to create a resource. Next, we enter the appropriate URL for the user resource. The Body section allows us to specify the data we want to send. We select raw format and indicate that we’re sending JSON data. We enter the name and email of the new user, Charlie. Finally, we hit the Send button to execute the request, which should create the new user in the system.

Imagine adopting a pet from a shelter. You go to the shelter (the API), fill out the application with your details (the JSON data), and hand it to the staff (the server). Once they process your application (you hit Send), you have successfully adopted a new pet (a new user is created).

Postman allows you to write JavaScript-based tests under the Tests tab to automate validation of response data. 🧪 Common Assertions: // Status code is 200 pm.test("Status code is 200", function () { pm.response.to.have.status(200); }); // Response contains expected field pm.test("Response has user name", function () { var jsonData = pm.response.json(); pm.expect(jsonData.name).to.eql("Charlie"); });

In Postman, after sending an API request, you can validate the response using assertions, which are scripts written in JavaScript. This is done under the Tests tab. For example, you can check if the server responded with a status code of 200, indicating a successful request, by writing a simple assertion. Additionally, you can assess whether the response contains expected elements or values; for instance, verifying that the name in the returned JSON matches 'Charlie'. Writing these tests helps automate the validation process and ensures that the API behaves as expected.

Consider this like a quality check after cooking a dish. After preparing the meal, you taste it (validate the response) to see if it meets your expectations—if it’s not too salty or if it has the garnish you like (correct status code and expected fields). This way, you ensure every dish is up to your standard before serving it.

Test Type Example Status Code Check for correct HTTP status (200, 201, 400, 404, 500) Validation Response Verify fields like id, name, etc. Body Check Field Data Type Ensure id is an integer, email is a string Check Authorization Send without token and verify 401 Unauthorized Test Negative Send invalid data, expect proper error message Testing

Having a checklist for API testing is essential to ensure comprehensive validation of the API behavior. This checklist might include different types of tests, such as checking the status code to ensure that the API returns the correct HTTP response (like 200 for success). Validation checks ensure that the returned response has all the expected fields, such as user IDs and names. Other checks involve ensuring that the data types in the response are as expected—ID should be an integer, and the email should be a string, amongst others. It is also crucial to test authorization by sending a request without proper authentication and checking for errors (like a 401 Unauthorized). Lastly, conducting negative testing involves sending invalid data to ensure that the API responds correctly with the appropriate error messages.

Think of this as a final inspection before a car leaves the factory. You check the engine status, ensure that all systems work correctly, verify that the color matches the customer's order, and run tests to see if it starts with various key conditions (authorization). This comprehensive quality check ensures that the car meets all specifications before it’s delivered to the customer.

Concept Description REST API API that uses HTTP methods to access resources Postman Tool for sending, viewing, and testing API requests Assertions Scripts to validate status codes, fields, values Common GET, POST, PUT, DELETE Methods

In summary, REST APIs are crucial for enabling interaction between different systems using standard HTTP methods like GET, POST, PUT, and DELETE. Postman serves as an effective tool for anyone engaged in API development and testing, allowing them to send requests, view responses, and perform rigorous tests on API behaviors. Assertions are scripts that automate the validation of responses, ensuring correctness in the data being returned. Understanding these key concepts forms the foundation for efficient API testing.

Imagine learning to drive. You acquire knowledge about the car (API), practice driving (using Postman), and develop habits of checking safety measures (writing assertions). Each of these components, when mastered, allows you to navigate the roads safely and efficiently—similarly, understanding REST APIs, Postman, and assertions enables effective API interaction and testing.

--