API Testing with Postman

Application programming interfaces (APIs) are crucial connectors enabling software systems to communicate. They establish rules for requesting and exchanging data, promoting efficient integration and standardized communication between applications. APIs are used in all kinds of applications, from finance and banking to the Internet of things (IoT). Begin this course by discovering how APIs allow you to integrate software systems, increase security, and standardize messages. Next, you will explore the different types of APIs, including Representational State Transfer (REST), simple object access protocol (SOAP), Graph Query Language (GraphQL), and Google Remote Procedure Call (gRPC). Finally, you will examine RESTful architecture in more detail and focus on best practices of API design and the importance of API versioning.

When working with application programming interfaces (APIs), two popular tools are cURL and Swagger. cURL, a command-line utility, empowers direct HTTP requests from the terminal, while Swagger offers an interactive interface for exploring APIs, simplifying request and response inspection. Both enhance your API interaction capabilities. Begin this course by discovering common representational state transfer (REST) APIs that use JSON data. You will view the different types of data available and analyze the URLs of these APIs. Then you will use the Inspect feature of Chrome DevTools and the Swagger UI to view network requests. Next, you will learn how to use the client for URL (cURL) utility and place GET requests using cURL. You will work with POST requests to add new resources, use PUT and PATCH requests to completely and partially update resources, respectively, and use DELETE requests to remove resources. Finally, you will authenticate yourself with GitHub and explore GitHub API real-world use cases.

Postman is a widely used application programming interface (API) development and testing platform that simplifies the process of designing, testing, and managing APIs. This versatile tool allows developers to create and send HTTP requests, supporting various request types such as GET, POST, PUT, and DELETE. You will start this course by learning about Postman, which will allow you to send requests to HTTP APIs and perform tests on the responses, including unit testing, function testing, and end-to-end testing. Next, you will install Postman and utilize it for making requests. You will configure and set up GET requests to access resources, POST requests to create resources, PUT and PATCH requests to update resources, and DELETE requests to remove resources. Finally, you will experiment with PUT, PATCH, and DELETE requests and incorporate query parameters and path variables in your request URLs to specify filters or selection in GET requests. You will also explore headers for requests, allowing specification of information like the acceptable response format.

Postman is a powerful tool for API testing, offering a comprehensive suite of features to streamline the testing process. With Postman, you can create and execute a variety of HTTP requests, including GET, POST, PUT, and DELETE, allowing you to thoroughly test different aspects of your API. You will start this course by setting up your own API server utilizing the Flask library from Python. You will send requests using Postman, including basic GET and POST requests, and view the responses. You will learn how to create test scripts to test the responses from your APIs and use them to perform checks, such as verifying the status code or response body to ensure a successful request. Next, you will explore working with collection runners, which allows you to configure scheduled executions or introduce delays between your requests. Then, you will delve into authentication, a crucial aspect in most real-world APIs. Request senders usually authenticate themselves using mechanisms such as basic authentication, digest authentication, and bearer token authentication and you will work with all these authentication types. Finally, you will explore header presets, configuring header fields included in all requests.

In Postman, variables play a pivotal role in enhancing flexibility and efficiency throughout the application programming interface (API) testing and development process. These variables provide a dynamic way to handle changing values, such as ports, URL app routes, or data within a request body. In this course, you will begin by working with variables, including global variables, collection variables, and environment variables, and learning when to use each type. Moving on, you explore secret variables, which keep their value hidden, and thus are ideal for storing sensitive information like passwords. You will see how you can use the UI, pre-request scripts, and tests to configure and access these variables. Next, you delve into request chaining, linking all requests in a collection such that each request depends on the previous ones in sequence. Finally, you explore the Postman command line interface (CLI). You will install this on your local machine and use it to run collections.

End-to-end testing with Postman is a crucial aspect of ensuring the seamless functionality and reliability of application programming interfaces (APIs). In the context of Postman, end-to-end testing involves evaluating all facets of an API's functionality by simulating real-world user scenarios. You will begin this course by performing end-to-end testing of your APIs, targeting all aspects of their functionality with simulated user requests. You will also learn how you can perform looping in Postman. You will configure loops to allow you to execute the same request multiple times before moving to other requests in your collection. Following that, you will learn to create mock servers, a technique useful for testing API functionality before its development is complete. You will also learn how to configure the API to return correct responses and error responses. Next, you will explore how to perform collection monitoring, allowing you to automate and schedule the execution of a request or collection. Finally, you will generate and publish documentation for your requests.

Basic performance tests with Postman involve assessing the responsiveness and efficiency of an application programming interface (API) under conditions of heavy load. These tests typically focus on evaluating key performance metrics such as response times, throughput, and error rates when a large number of requests are made concurrently. Postman allows you to create a collection and run this as a performance test to test the scalability and reliability of your API. Begin this course by discovering how performance testing works. You will learn the steps involved in performance testing and the metrics that you can use to evaluate API performance. Next, you will set up a basic Python API running locally on your machine that stores data in a PostgreSQL. Finally, you will perform a full-scale performance test with Postman, configuring the number of virtual users to make requests to your API. You will learn to observe and interpret the metrics and errors for your requests and use different load profiles such as fixed and ramp up to run performance tests.

A number of factors affect your application programming interface's (API's) performance - the system's design, the system resources of your API server, and whether you use caching or not. Performance testing using Postman and niche tools such as k6 can help identify scalability issues and bottlenecks in your system. Begin this course by setting up a cloud-hosted API server on the Google Cloud Platform (GCP). Then you will set up a PostgreSQL database on the cloud and use that as the backend of your API server. Next, you will run performance tests using Postman and identify how a poorly designed system results in very high average response times for requests. You will explore the effects of other configurations on performance such as system resources, caching, and slow-running requests, and learn how to debug these issues using Postman performance testing. Finally, you will run performance tests using k6, including stress, soak, spike, and breakpoint tests, all designed to test different load scenarios.

Application programming interface (API) security testing is the practice of identifying and addressing vulnerabilities in the API server. Authentication and authorization play a pivotal role in securing APIs, but vulnerabilities may still emerge due to complex systems, rapid development, and third-party components. In this course, you will learn the basic building blocks of implementing application security. You will examine the Open Web Application Security Project (OWASP) Top 10 lists of application and API security vulnerabilities, which research and document the most common security vulnerabilities for applications and provide guidance on how these issues can be mitigated. Then you will set up an API server with basic authentication for security and set up success-flow and failure-flow tests. Next, you will explore defense strategies against structured query language (SQL) injection errors and write tests to inject malignant SQL queries to run against the back-end database. Finally, you will discover how SQL best practices can help mitigate SQL injection attacks.

Contract testing ensures a seamless conversation between two parties, typically an application programming interface (API) server and its client. It involves defining a "contract" that specifies the expected behavior and data structures of each participant. This contract acts as a blueprint, guaranteeing that both parties communicate efficiently and adhere to the agreed-upon rules. This course will introduce you to contract testing. Lightweight tests will verify both parties adhere to this contract, helping detect and resolve issues early in development. You will learn how contract testing differs from integration testing and you will explore the basic structure of Open API, a popular specification for defining API contracts. Next, you will learn to create API contracts using Open API in Postman. You will define the endpoints, requests, and responses exposed by our API server using Open API 3.1. Finally, you will explore contract testing. You will perform basic checks on the response schema and body using Postman. You will also use the publicly available Postman contract test generator to run tests.

Automation testing streamlines the software development process by replacing manual testing with automated scripts. These scripts can execute repetitive tasks, freeing up valuable developer time to focus on more complex aspects of development. This course will introduce you to automation testing, the process of programmatically executing tests at predefined frequencies or within your continuous integration and continuous delivery (CI/CD) workflow. Next, you will create a production-scale application programming interface (API) server on the Google Cloud Platform (GCP) and install the Newman command line interface (CLI) for Postman. You will then explore running collections using Newman CLI and analyze test results in requests. Finally, you will configure CI/CD pipelines using GitHub Actions. This involves creating a local Git repository and linking it to a remote GitHub repository. You will then push your Postman tests to these repositories. You will create a GitHub Actions pipeline to run on a push to the main branch and execute tests stored in your GitHub repository. You will also learn how to view test results and send an email when the workflow runs to completion.

GraphQL is a query language and runtime for application programming interfaces (APIs), offering a flexible and efficient approach to data fetching. Unlike traditional REST APIs, which require multiple requests to retrieve specific data, GraphQL allows you to request exactly what you need in a single request. You will begin this course by exploring a test GraphQL API hosted by the Hasura.io platform. You will discover how to use the GraphQL interface to query the API server to retrieve data and to perform modifications. Next, you will structure request documents with clauses and conditions to retrieve exactly the information you want from the API server. You will use filters to specify conditional predicates for the data you want to retrieve. Additionally, you will explore using query variables to modify filter values. Following queries, you will delve into mutations, commands to modify server resources. Finally, you will use Postman to send GraphQL requests. You will send requests, execute pre-request and test scripts, and confirm successful query execution by examining the response body.

Final Exam: Software Testing will test your knowledge and application of the topics presented throughout the Software Testing journey.