API Testing Course

by

What We Are Learn:

01 API – Intro Session Course Basics Of APIs

00:00 📚 Introduction to API Testing

  • API testing is different from web automation, requiring a fundamental understanding of APIs, including terminology, naming conventions, verbs, and technical keywords.
  • Backend APIs are invisible, and testing involves playing with URLs and understanding how data is transmitted.
  • API testing is essential, as many companies rely on backend automation, making it a valuable skill.

02:37 🧪 Introduction to Postman and Manual API Testing

  • Postman is a powerful tool for manual API testing and automation.
  • Postman offers a wide range of features, including developing mock services, authentication, and running tests from the command line.
  • Learning Postman is crucial, as it’s highly demanded in the market and adds value to your resume.

07:40 🛠️ Preparing for Automation

  • Basic Java knowledge is required for API automation using libraries like Rest Assured.
  • Rest Assured is a popular Java library for API testing and supports various HTTP methods.
  • TestNG is used for validations, and Maven is essential for project development and dependency management.

13:13 📜 Learning Java for API Testing

  • Basic Java concepts such as classes, getters, setters, and method invocation are necessary for API automation.
  • While in-depth Java is not covered, a minimal understanding is required for API automation.
  • Java videos will be shared for self-study.

14:33 🚀 Beginning with Rest Assured

  • Rest Assured is a dedicated Java library for API testing, offering extensive capabilities for sending requests, getting responses, and validating them.
  • It supports both BDD and non-BDD approaches, making it versatile for different testing styles.
  • TestNG and Maven are used in conjunction with Rest Assured for validation and project management.

19:40 ☁️ Using Docker in API Automation

  • Docker is utilized for API automation, allowing for easy setup and sharing of test environments.
  • API automation doesn’t require browser automation, making cloud infrastructure unnecessary.
  • Docker images can be created, shared, and run locally for efficient API testing.

21:03 📝 Understanding the role of APIs and the significance of API communication.

  • APIs act as mediators between systems, enabling communication and data exchange.
  • APIs help maintain security and enforce business logic by centralizing data access.

25:04 📊 Challenges in API testing, especially with public APIs.

  • Testing public APIs poses challenges due to the lack of access to private APIs.
  • Testing various public APIs with authentication and authorization requirements is essential in practice.

28:02 📄 Significance of RFC (Request for Comments) documentation for APIs.

  • RFC documentation provides standardized guidelines and best practices for HTTP protocols and API design.
  • Understanding RFC documentation is crucial for testers to ensure compliance with industry standards.

32:30 🍔 Analogy of APIs as mediators in client-server architecture.

  • APIs serve as intermediaries between clients and servers, allowing secure and structured data exchange.
  • APIs enhance security, business logic separation, and data access control in client-server interactions.

42:59 🔗 Overview of HTTP methods (GET, POST, PUT, DELETE) used for API communication.

  • HTTP methods, including GET, POST, PUT, and DELETE, provide specific actions for API requests.
  • Understanding these methods is essential for effective API testing and communication.

43:28 📚 Understanding HTTP Methods

  • HTTP methods include GET, POST, PUT, and DELETE.
  • GET is for retrieving data, POST for creating, PUT for updating, and DELETE for removing.
  • CRUD operations can be mapped to these methods: Create, Read, Update, and Delete.

44:58 📖 Semantics and Naming Conventions

  • Semantics refer to the meaning of terms in the context of APIs.
  • Proper naming conventions in APIs include using plural nouns for resources and avoiding verbs.
  • Query parameters and sorting using query parameters are common in API requests.

47:09 🔄 API Versioning

  • APIs can have different versions to maintain backward compatibility.
  • Users can choose to use a specific version of the API to avoid forced upgrades.
  • Backward compatibility is crucial to prevent disruption for users.

01:07:44 🛠️ Explanation of making API requests and using queries,

  • Understanding how queries filter data.

01:08:11 🔒 Types of APIs: No Auth vs. Auth APIs,

  • Explanation of public APIs that don’t require authentication,
  • Importance of authentication for secure access.

01:09:26 🕵️ Understanding the need for authentication in APIs,

  • Exploring the concept of using tokens, API keys, or passwords for authentication.

01:12:38 ⏰ Token expiration in APIs,

  • Explaining the concept of token expiration for security reasons.

01:14:06 🚫 API request limitations,

  • Discussing limitations on the number of API requests within a certain time frame.

01:15:18 🏢 Postman workspace and collections,

  • Introduction to Postman’s workspace and collection structure for organizing APIs.

01:17:40 🚀 Creating and running test cases in Postman,

  • Demonstrating the process of creating and running test cases in Postman.

01:19:21 🗓️ Course duration and schedule,

  • An overview of the course duration and scheduling for the training.

01:21:44 🔄 Adaptability of REST Assured and Postman,

  • Explanation of the versatility of REST Assured and Postman in API testing.

01:25:24 🔄 Combining Selenium and REST Assured,

  • Discussing the integration of Selenium and REST Assured for web and API automation.

01:28:52 🆚 Comparing Postman to other tools like Insomnia,

  • Highlighting the similarity between Postman and other API testing tools.

01:29:33 ❌ Disadvantages of Karate,

  • Providing insights into the limitations and complexities of using Karate for API testing.

01:30:58 📚 Overview of API Testing in Karate

  • API testing in Karate involves writing feature files with specific requirements.
  • Karate may seem daunting at first due to the syntax, indentation, and other details.

01:32:12 🤖 API Testing Is Component-Level

  • API testing differs from UI testing as it focuses on testing individual components rather than user journeys.
  • No user journey or flow is involved in API testing; it’s more about component testing.

01:33:00 💡 Integration and Schema Testing in API Automation

  • API testing extends to integration testing when systems need to interact, e.g., between teams in the same company.
  • Schema testing and automation of request-response validation are integral parts of API testing.

01:36:38 📦 Recording Session Access and Usage

  • Session recordings are accessible through Box Drive.
  • Invitations to access recordings are sent to your email.

01:38:38 🎯 Effort Estimation in API Testing

  • Estimating effort in API testing depends on the number of APIs, test cases, and test cycles.
  • A matrix approach can help track coverage and progress.

01:41:52 📝 API Documentation and Acceptance Criteria

  • API documentation, often in tools like Swagger, provides a detailed understanding of the API.
  • Acceptance criteria for APIs are not usually as explicit as they are for web applications.

01:45:49 💡 Advantages of API Automation

  • API automation is simpler and faster than UI automation, with no browser interaction required.
  • API test cases can be created quickly, and repetitive test cases are easy to generate.

01:52:06 🚫 Avoiding Cucumber for API Testing

  • Using Cucumber for API testing may not be the best approach.
  • RestAssured provides BDD-style methods without the need for feature files.

01:55:00 🗓️ Course Duration and Schedule

  • The course is held three days a week for 1 hour 15 minutes each session.
  • Students may have initial doubts which will be managed.

01:55:42 📊 Data-Driven Testing with Postman

  • Postman uses JSON and CSV for data-driven testing.
  • Loops and variables will be covered for handling JSON arrays.

01:56:49 🤝 Interaction and Questions

  • The instructor encourages students to ask questions during the session.
  • Questions can be asked through the chat, and most will be addressed during the session.

01:58:03 📄 Resume Experience

  • After completing the course, students can show their experience in API testing on their resumes.
  • The instructor advises students to be realistic about the years of experience they claim.

02:00:02 📊 Postman vs. Rest Assured

  • Postman is user-friendly and designed for various users, including non-technical ones.
  • Rest Assured is more technical and suited for automation engineers.

02:01:15 📃 Resume Keywords

  • Specific keywords to include in resumes will be discussed later in the course.

Postman Tutorial

02 PM 01 – Rest API Intro REST Guidelines POSTMAN SETUP Collection Folder Request GET POST Examples

00:00 📚 Understanding APIs and Basic Concepts

  • API stands for Application Programming Interface and is a way for different software systems to communicate.
  • APIs act as mediators between clients and servers, facilitating proper communication.
  • There are various types of APIs, and they have been around for over 20 years.

01:09 🛡️ Introduction to REST API

  • REST API, or Representational State Transfer API, is an architecture or pattern for designing APIs.
  • REST API is not a protocol but follows certain guidelines based on RFC documents.
  • REST APIs are commonly used for web communication.

03:40 📡 Principles and Features of REST API

  • REST APIs should follow the client-server architecture, where clients and servers interact.
  • Stateless communication is a fundamental feature of REST APIs, meaning the server doesn’t retain information about the client between requests.
  • REST APIs are designed to work over the HTTP protocol and are inherently stateless.

22:12 🌐 Stateless vs. Stateful Communication

  • Stateless communication means that each request to the server requires fresh information about the session and user.
  • Stateful communication involves an established connection between the client and server, with ongoing communication without repeating session data.
  • WebSockets are an example of a stateful communication protocol.

23:03 🌐 Key Takeaway: REST API Guidelines – Stateless Communication

  • REST APIs should follow stateless communication, meaning each request is independent, not dependent on previous ones.
  • WebSocket architectures, in contrast, are stateful and not part of RESTful APIs.

25:03 🔍 Key Takeaway: Caching in REST APIs

  • Caching in REST APIs can improve performance by storing frequently requested data.
  • Clients can access data from a caching server instead of repeatedly hitting the main server, saving time.

27:05 🌟 Key Takeaway: Uniform Interface and HTTP Status Codes

  • REST APIs should have a uniform interface, with consistent naming conventions for methods (GET, POST, PUT, DELETE).
  • They should support different data types (JSON, XML, HTML) based on client preferences.
  • Proper HTTP status codes (e.g., 200, 201, 400) should be used for clear communication between the server and client.

32:47 📄 Key Takeaway: HATEOAS – Hypermedia as the Engine of Application State

  • REST API responses should include hypermedia links for easy navigation, allowing clients to access related resources by following links.
  • Hypermedia links should facilitate client interaction without manual URL manipulation.

36:17 📑 Key Takeaway: Schema Validation in REST APIs

  • Schema validation ensures that the structure of responses remains consistent, preventing unexpected changes.
  • A breach of the contract between client and server can lead to issues, so maintaining schema consistency is crucial.

41:35 🌍 Key Takeaway: Understanding URI, URL, and URN

  • URI (Uniform Resource Identifier) is a broader term that encompasses URLs and URNs.
  • URL (Uniform Resource Locator) is a specific type of URI and includes the protocol (HTTP), subdomain, hostname, path parameters, and query parameters.
  • URN (Uniform Resource Name) is another type of URI and may not necessarily specify a location like URLs.

47:06 📂 Key Takeaway: URI Components

  • URI components include the scheme/protocol (e.g., HTTP), subdomain, hostname/domain, path parameters, query parameters, and anchor/fragment.
  • Query parameters are used to filter and retrieve specific data, and anchor/fragment helps navigate to a particular section within a resource.

49:50 📝 Overview of URI and URL

  • URI stands for Uniform Resource Identifier, which encompasses various parts of a web address.
  • URL, or Uniform Resource Locator, is a specific type of URI that includes the protocol, domain, and optional query parameters and fragments.

56:15 📋 Postman Setup

  • Postman is a free tool for API testing and development, available for both Mac and Windows.
  • Postman can be used as a web application or installed on your local machine.

59:37 🖥️ Creating Workspaces and Collections in Postman

  • Workspaces are used to organize your API testing projects in Postman.
  • Collections are a way to group related API requests and responses within a workspace.

01:10:12 🌐 Creating a Get Request in Postman

  • In Postman, you can create a Get Request to retrieve information from a specific URL.
  • Get requests do not typically include a request body, and they are used to fetch data from a server.

01:14:04 📜 Introduction to REST API response

  • Explanation of the structure of a REST API response.
  • Overview of JSON key-value pairs, raw format, and pretty format.

01:15:01 🍪 Cookies and Headers in Response

  • Introduction to cookies in the response and their purpose.
  • Explanation of response headers, including content type and server information.

01:16:52 🧪 Testing and Response Information

  • Overview of the test result section in the response.
  • Information on response size, response time, and successful requests.

01:17:59 📝 Different HTTP Methods

  • Explanation of HTTP methods, such as GET and POST.
  • Illustration of what happens when using an inappropriate HTTP method.

01:19:09 📦 Creating a POST Request

  • Steps to create a POST request, including selecting the method and setting the URL.
  • Demonstrating the use of different request body formats, including JSON and plain text.

01:28:17 📊 Comparing JSON and XML

  • Comparison of JSON and XML in terms of readability and efficiency.
  • Discussion of the flexibility of REST APIs in handling different data formats.

03 PM 02 – GOREST API GET POST PUT DELETE Auth Token PUTvsPOST DB WIth API

00:00 🛠️ Setting Up Postman and Introduction

  • Make sure to download Postman for API testing.
  • Postman is essential for API testing, and the videos and Java materials are available for reference.

02:23 📝 Basics of API Testing with Postman

  • Understand the difference between GET and POST requests.
  • Explore the basics of making GET and POST requests using a sample API.

05:07 🌐 Using the goREST API for Practice

  • Introduce the goREST API, a resource for practicing API testing with fake data.
  • Highlight the base URL and different API endpoints available for testing.

08:06 📬 Making a GET Request to Retrieve Users

  • Create a Postman request to fetch all users from the goREST API.
  • Demonstrate how to structure a GET request and retrieve user data.

11:53 🧾 Creating a POST Request to Add a New User

  • Set up a Postman request to create a new user in the goREST API.
  • Show how to pass JSON data in the request body and include the authorization token for authentication.

15:06 🧾 Understanding Data Schema and Auth Tokens

  • Explain the required data schema for creating a user in the goREST API.
  • Emphasize the importance of including the authorization token when making requests.

16:49 🚫 Handling Errors in API Requests

  • Discuss how to handle different types of errors, such as unauthorized access and validation errors.
  • Address the importance of correctly structuring the request data.

21:34 🛠️ Troubleshooting API Requests

  • Demonstrate common issues and how to troubleshoot them, including handling errors related to data validation and missing data.
  • These sections cover the key takeaways and topics related to API testing with Postman and using the goREST API for practice.

22:04 🛠️ Understanding POST Request Validation

  • When creating a new user via a POST request, certain fields like name, email, gender, and status are mandatory.
  • The API responds with a 422 error if gender and status are left blank, enforcing data validation.

23:58 📜 Analyzing Response Headers

  • Examining the response headers, including content type, server date, and other metadata.
  • Response codes, such as 201, 400, and 404, are predefined by the API developers, not by Postman.

26:08 🔄 Introducing the PUT Request

  • Exploring the PUT request, which is used to update existing user data.
  • Demonstrating how to structure the request URL and handle authentication.

30:25 📥 PUT Request Behavior

  • Clarifying that a PUT request updates the entire user object, not just the changed fields.
  • Emphasizing that a PUT request does not create duplicate entries in the database.

43:03 🧩 Understanding PATCH Requests

  • Introducing the PATCH request, which allows partial updates to user data.
  • Demonstrating how to structure the request for updating specific fields.

46:20 🛡️ PATCH vs. PUT

  • Highlighting the difference between PATCH and PUT requests.
  • Showing that a PATCH request can update specific fields without affecting the entire user object.

46:34 🔄 Overview of HTTP PUT and PATCH

  • The difference between PUT and PATCH in HTTP methods.
  • PUT updates all columns in the data, while PATCH allows updating specific information, like the user’s status, without touching other columns.

51:21 🗑️ Understanding DELETE in HTTP

  • Explains the DELETE HTTP method for removing data.
  • Demonstrates how DELETE is used to delete a user by passing the user ID.

59:56 🛡️ API Safety: GET, PUT, and POST

  • Discusses the safety of different HTTP methods.
  • GET is considered safe, while PUT and POST have different safety characteristics, with PUT being idempotent.

01:11:01 🌐 API Interaction and Data Storage

  • Describes the role of API in interacting with data stored in a database.
  • Clarifies that APIs do not store data themselves but interact with the database.

01:14:52 🌐 Introduction to API Gateways

  • Explains the purpose of API Gateways in routing and managing different types of API requests.
  • Highlights the importance of API Gateways in handling diverse user demands.

01:15:48 🌐 Understanding API Gateway Functionality

  • API Gateway decides routing for different client requests.

01:16:16 🌐 Advantages of API Gateway

  • Efficient routing prevents resource occupation and lost requests.
  • Can act as a load balancer, distributing requests to multiple servers.
  • Offers caching to reduce repetitive server queries.

01:19:36 🌐 Additional API Gateway Features

  • Provides analytics for tracking API usage.
  • Supports schema documentation for APIs.

01:27:13 🌐 Demonstrating API Operations

  • Showcase of GET, POST, PUT, and DELETE API operations.
  • Real-time interaction with APIs and their effects on the database.

01:41:21 📚 Understanding API and database interaction

  • APIs should interact with databases to create, update, and retrieve data.
  • Proper connection and schema between APIs and databases are essential for error-free operations.

01:42:44 🤔 Handling API, client, and database interactions

  • The relationship between the client, API, and database, and how they affect data retrieval.
  • The importance of verifying that data from the API matches the data in the database to ensure proper functionality.

01:45:10 🧪 Testing APIs with Post, Get, Put, and Delete

  • A recommended sequence for testing APIs using Post, Get, Put, and Delete methods.
  • Highlighting the need to create a fresh user when testing APIs to ensure accurate results.

01:56:25 🔄 Differences between PUT and PATCH

  • Clarification on the differences between the PUT and PATCH methods for updating data in APIs.
  • Explaining how PUT typically requires sending the full object, while PATCH allows partial updates.

02:02:03 📑 Authentication and OAuth

  • Discussing the importance of authentication in API testing.
  • Mentioning the use of client ID, client secret, and refresh tokens in OAuth 2.0 for authentication.

02:05:52 💡 Understanding the importance of a primary key in the database for APIs,

  • Primary key is crucial for maintaining data integrity in the database.
  • The primary key might be a mandatory field at the API level.
  • Discusses the need for negative testing to ensure API validation.

02:07:01 🌐 API validation and handling different data types,

  • Some APIs may lack proper validation for certain fields, allowing unexpected data types.
  • Explains the importance of testing different data types for robust API testing.
  • Mention of how the API’s schema can affect the data type expectations.

02:09:02 🤖 Delving into automation and running collections,

  • Discusses the transition from manual to automated testing in Postman.
  • Hints at the upcoming coverage of automation and test prerequisites.
  • Mentions the use of tools like Newman and Jenkins for automation.

02:11:01 🕒 Addressing potential data recovery in APIs,

  • Explores the possibilities of data recovery or backup services for deleted entries in the production environment.
  • Emphasizes the importance of being cautious while using delete APIs.
  • Touches on the differentiation between development and database testing.

02:13:01 🚧 Starting with the fundamentals and terminologies,

  • Highlights the significance of understanding API fundamentals before delving into automation.
  • Emphasizes the need to comprehend key concepts such as status codes and database components.
  • Navigates learners through the architectural components.

02:14:57 🧩 Choosing the right technology for API development,

  • Discusses the technology choices for developing APIs, including Java, Spring, Node.js, and Python.
  • Encourages learners to explore technologies aligned with their programming background.
  • Provides insights into different technologies used for creating APIs.

02:16:44 📊 Insights into setting up an AWS environment for APIs,

  • Shares details about the AWS setup for deploying a Spring Boot application.
  • Describes the creation of an AWS Linux machine server and database hosting services.
  • Offers a glimpse into the architecture and hosting of APIs on AWS.
  • These sections cover various aspects of API testing, from database key importance to automation, technology choices, and insights into the AWS setup for API deployment.

04 PM 03 – Idempotent Concept HeadVsOptions Console Global Environment Collection Variables Test Case

00:00 📋 Introduction and Setup

  • Introduction to the session and setting up the environment variables in Postman.
  • Creating environment variables for base URL and authentication token.

06:12 🌐 HTTP Methods: GET, HEAD, and OPTIONS

  • Explaining the difference between the GET and HEAD HTTP methods.
  • Demonstrating how to use the OPTIONS method to check which HTTP methods are allowed for a specific API endpoint.

16:47 🔄 Parameterization and Dynamic Data

  • Parameterizing the base URL and authentication token to make requests more flexible and maintainable.
  • Using random data generation for email IDs to ensure unique values in requests.

These sections provide insights into setting up Postman environments, understanding different HTTP methods, and making requests more dynamic and reusable.

21:43 📋 Creating Multiple Environments

  • You can create multiple environments in Postman without any limits.
  • Environments are useful for managing configuration variables like base URLs, usernames, and passwords.

26:34 🗃️ Global and Collection Variables

  • Global variables are available across all collections in your workspace and are ideal for common variables like API keys.
  • Collection variables are specific to a particular collection and can override global or environment variables.

36:13 🪛 Working with Postman Console

  • Postman Console is a helpful tool for debugging API requests.
  • It provides detailed logs, including request headers, response data, and more.

42:08 🔢 Variable Preference Hierarchy

  • When a variable has the same name in different scopes (Global, Collection, Environment), Postman follows a specific hierarchy to determine which one to use.
  • Global variables take precedence over Collection variables, and Collection variables take precedence over Environment variables.

45:49 🔑 Introduction to different types of variables in Postman

  • There are three main types of variables in Postman: local variables, collection variables, and environment variables.
  • Local variables are specific to the script where they are created.
  • Collection variables are specific to the collection and can be used across requests within that collection.
  • Environment variables are specific to the environment and can be used in all requests within that environment.

55:13 🔑 Writing test cases in Postman

  • Test cases can be written in Postman to verify the correctness of API responses.
  • The primary method for writing test cases is to use the pm.test function.
  • Test cases typically include assertions to verify specific conditions in the response, such as the status code or the presence of specific data.

01:05:20 🔑 Importance of separate assertions in test cases

  • It’s essential to separate assertions into individual test cases to ensure that each assertion is independently evaluated.
  • Using separate test cases for each assertion helps in pinpointing which specific condition failed in case of a test failure.

01:09:32 🔍 Common assertion for API testing: Status codes

  • Understanding the importance of common assertions in API testing.
  • Exploring the significance of checking status codes for different API requests.
  • Demonstrating how to set up a common test for status codes at the collection level.

01:16:05 🧐 Running a collection and customizing execution

  • Running a collection with selected requests and specifying the number of iterations.
  • Persisting responses for a session and managing advanced settings.
  • Understanding the impact of test results and getting a summary report after running the collection.

01:21:20 📂 Organizing requests in folders

  • Emphasizing the importance of organizing requests into folders for better maintenance.
  • Creating folders based on different API operations (GET, POST, PUT, DELETE).
  • Writing common tests at the folder level for specific requests.

01:29:27 📝 Handling common tests using if conditions

  • Exploring an alternative approach to handle common tests using if conditions at the folder level.
  • Writing if conditions to check the request method and set specific assertions based on the request type.
  • Highlighting the limitations of this approach due to less organized folder structure.

01:34:25 📦 Sharing Collections in Postman

  • Learn how to share collections in Postman.
  • Export collections as JSON files.
  • Import collections into Postman.

01:37:23 🌐 Importing Collections and Using Environment Variables

  • Importing collections and creating environment variables in Postman.
  • Explaining the difference between collection and environment variables.
  • Demonstrating how to use variables in Postman.

01:54:59 🧪 Handling Negative Test Cases

  • Organizing test cases into folders for positive and negative scenarios.
  • Exploring the approach for negative test cases in Postman.
  • Understanding the flexibility of test cases in different folders.

02:00:30 🧐 Understanding the Role of Product Managers in API Testing

  • API testing and documentation typically involve QA and developers, with limited involvement from product managers.
  • Product managers focus on the UI and product-level functionality, not the specifics of API testing.

02:01:12 🧰 Integrating API Testing into Jenkins CI/CD Pipeline

  • Exploring the integration of API testing using Newman in Jenkins CI/CD pipelines.
  • Discussing how to run test cases on specific environments and postman or REST Assured test cases.

02:02:18 🏋️ Load and Performance Testing with Postman

  • Mentioning the limited load and performance testing capabilities in Postman.
  • Suggesting alternatives like JMeter and Gatling for comprehensive performance testing.

02:03:27 🤝 Collaborating with Developers on Test Cases

  • Emphasizing the need for collaboration with the development team for verifying test cases.
  • Highlighting the importance of test case documentation based on Swagger or API specifications.

02:04:10 📊 Generating Test Reports and Viewing Logs in Postman

  • Discussing how Postman generates test reports for pass and fail scenarios.
  • Exploring the built-in logs and log export options in Postman.

02:06:26 📜 Creating Detailed Test Reports

  • Preparing detailed test reports for pass and fail test cases, separate from bug reports.
  • Indicating that specific plugins may be used to generate these reports.

02:07:19 🖥️ Scripting in Postman

  • Clarifying that scripting in Postman involves basic JavaScript for test cases.
  • Advising against using Postman for complex framework design.

02:08:50 📜 Importance of Collaboration and Using Predefined Methods

  • Highlighting the predefined methods in Postman, such as pm.taste and pm.expect.
  • Emphasizing the simplicity of Postman scripting compared to complex JavaScript frameworks.

02:11:16 🧩 Separating API Requests in Collections

  • Recommending creating separate requests for different API functionalities, like login, search, payment, and logout.
  • Ensuring sequential execution of these requests for end-to-end testing.

05 PM 04 – CRUD Worflow End To End Tests Run From CLI CLI Setup Pass Global Var With CLI

00:01 📝 Understanding the difference between POST, PUT, and PATCH requests

  • POST request is used to create new entries, like users, accounts, customers, or employees, and each call creates a new entry.
  • PUT and PATCH requests are used to update existing information. They don’t create new entries.

02:06 📊 The preference order for variable resolution in Postman

  • The order of variable preference in Postman is: environment variable, collection variable, and then global variable.
  • Environment variables take precedence over collection and global variables.

05:28 🌐 Using local variables to pass data between requests

  • Local variables, created within the script, can be used to pass data between requests in a collection.
  • You can set local variables using PM.variables.set('variableName', value) and use them in subsequent requests.

11:03 🔄 Creating a workflow in Postman to create, retrieve, update, and delete user data

  • Demonstrates how to create a workflow in Postman for CRUD operations: Create, Retrieve, Update, and Delete.
  • Shows how to pass data between requests, like capturing user IDs and using them in subsequent requests.

22:17 📌 Understanding local variable scope and environment variables,

  • Local variables take precedence over global variables,
  • Local variables are stored in environment variables.

23:00 📌 Working with variables to transfer data between requests,

  • Using local variables to transfer data,
  • Local variables get created during collection execution and get automatically deleted when the execution is over.

24:12 📌 Writing tests in Postman,

  • Creating test cases for HTTP status codes,
  • Verifying response data using test assertions.

26:11 📌 Updating user information with a PUT request,

  • Using the PUT request to update user details,
  • Adding headers and data to the request.

29:18 📌 Sending JSON payloads in requests,

  • Discussing how APIs expect JSON payloads,
  • Using request bodies for PUT and PATCH requests.

30:18 📌 Running a collection of requests and verifying results,

  • Running a collection of requests with shared local variables,
  • Verifying responses and ensuring data consistency.

34:58 📌 Performing a sequence of API requests,

  • Demonstrating a sequence of requests, including creating, updating, and deleting user data,
  • Verifying responses and data integrity throughout the sequence.

38:05 📌 Verifying dynamic data in Postman,

  • Extracting data from request bodies to validate responses,
  • Using variables and dynamic assertions for flexible testing.

40:15 📌 Parsing and validating JSON responses,

  • Extracting and parsing JSON data from response bodies,
  • Performing dynamic assertions on JSON values.

46:08 📦 Explaining how to fetch data from the request body.

  • Fetching data like name, email, and other variables from the request body.
  • Converting the request body into JSON format.

48:08 🧪 Demonstrating assertion writing for data verification.

  • Writing assertions to verify if data matches the expected results.
  • Using Postman to verify the name and email in the response.

56:08 🔄 Updating data and verifying the status in the response.

  • Updating data and checking the status in the response.
  • Using Postman to verify updated status in the response.

01:00:10 🧬 Running the entire workflow and discussing execution options.

  • Running the complete workflow within Postman.
  • Explaining execution options, including scheduling and CLI.

01:08:18 🖥️ Installing Postman CLI and obtaining an API key.

  • Demonstrating the installation of Postman CLI.
  • Explaining how to obtain an API key for CLI usage.

01:09:44 💼 Setting Up Postman API Key

  • To set up an API key in Postman, log in to your account and generate an API key with a name.
  • Copy the generated API key and save it for later use in your CLI commands.

01:11:08 🧐 CLI Workflow with Postman

  • You can run Postman collections from the command line interface (CLI) by executing specific commands.
  • When running collections from the CLI, you need to provide the API key explicitly, as it doesn’t automatically access global variables.

01:14:27 📝 Troubleshooting Collection Execution

  • If your Postman collection run from the CLI fails with authorization errors (401 unauthorized), it’s often due to missing or expired tokens.
  • You can pass global variables explicitly in CLI commands, but these variables need to be declared at the collection or environment level.

01:27:26 🔑 Collection-Level Variables

  • Variables set at the collection level in Postman can be used without passing them explicitly in CLI commands.
  • This eliminates the need to manually pass global variables when running collections from the CLI in Postman on the specific collection.

01:32:46 📈 Exploring Advanced Postman Features

  • Postman offers advanced features like array handling, data parameterization, and reading data from external JSON files for more complex testing scenarios.
  • You can use Postman for GraphQL testing as well, expanding its capabilities beyond traditional REST API testing.

01:34:19 🧐 Understanding API Content Length

  • Content length availability depends on API implementation.

01:35:16 🚧 Importance of CRUD Operations in Dummy APIs

  • Dummy APIs often prioritize CRUD operations like GET, POST, PUT, and DELETE.

01:35:59 📄 Understanding the Status Code of HEAD and OPTIONS Requests

  • HEAD request returns a status code of 200 OK.
  • OPTIONS request provides information about allowed HTTP methods.

01:36:33 🔐 Validating Encoded PDF in API Response

  • Encoded data needs to be decoded programmatically for validation.

01:37:18 🔑 Global Variables vs. Environment Variables

  • Global variables should be used as intended, not mixed with environment variables.

01:39:09 🐞 Fixing a Script Error in Postman

  • Correcting script syntax by using properties, not methods.

01:40:33 🌐 Importance of API Testing in Backend Development

  • Backend API testing is crucial to ensure the proper functioning of the system.

01:41:13 📂 Organizing API Tests into Collections and Folders

  • Grouping API tests into collections and folders for better organization.

01:42:29 🔄 Handling Status Code for POST Requests

  • Ensuring the correct status code (200 or 201) for POST requests.

01:44:37 🔃 Data-Driven Testing in Postman

  • Preparing for data-driven testing using external JSON files.

01:57:45 🤖 Using Postman for API Testing

  • Postman is a versatile tool for testing APIs, including web services and software.

01:58:42 🌐 Introduction to API Testing and CRUD Operations

  • API testing involves working with REST API endpoints.
  • CRUD operations (Create, Read, Update, Delete) are common in API testing.

02:00:10 🔄 Scope of Local Variables in Postman

  • Local variables in Postman have a scope within the same collection.
  • You can use local variables across folders in the same collection.

02:01:21 🗓️ Update on Session Schedule

  • The session will be moved to Friday due to the instructor’s unavailability on Thursday.
  • The change is for this week only to ensure a continuous session.

06 PM 05 – Basic Auth Token API Send Request Method Pre-Req Script Visualize Response Data Driven

00:01 📚 Introduction to API scenarios in Postman

  • Discussing the workflow in Postman.
  • Introduction to the API scenario involving token generation and usage.

01:10 🗝️ Generating a token with Basic Auth

  • Explaining the process of generating a token using Basic Auth.
  • Describing the API endpoint and the necessary header and body parameters for token generation.

02:07 🛠️ Using Basic Auth for Token Retrieval

  • Clarifying the use of Basic Auth for token retrieval.
  • Demonstrating how to fetch a token through a script in Postman.

04:25 📋 Using the Token in PUT and DELETE Calls

  • Discussing the token’s role in PUT and DELETE API calls.
  • Showing how to use the token as a header for these specific operations.

08:03 🧠 Understanding btoa Method and Basic Auth

  • Explaining the btoa method used for encoding username and password in Basic Auth.
  • Comparing Basic Auth with other authentication methods like OAuth.

10:32 📂 Organizing the API Workflow in Postman Collections

  • Demonstrating the organization of API requests into a Postman collection.
  • Saving various requests for different API endpoints and authentication scenarios.

19:08 🔄 Handling Token Expiry and Dynamic Tokens

  • Addressing the issue of token expiry and the dynamic nature of token IDs.
  • Exploring the need to programmatically generate fresh tokens before API calls.

23:37 📜 Explaining the PM.sendRequest Method

  • Understanding the PM.sendRequest method for creating requests.
  • Parameters involved: URL, method, header, and body.
  • Exploring how to set up headers for content type.

25:45 🤖 Utilizing JSON.stringify for Proper Data Format

  • Using JSON.stringify to convert text into JSON format.
  • Demonstrating how to format JSON data for the request body.
  • Ensuring the correct syntax for setting headers.

39:27 🔄 Reusing Variables in Prerequisites

  • Exploring the reuse of variables between different requests.
  • Using a token variable for multiple API calls.
  • Ensuring fresh tokens for each request to avoid expiration.

47:39 📋 Introduction to running requests in Postman

  • Explanation of running HTTP requests in Postman.
  • Highlighting the importance of dynamic token management in real-time projects.

48:40 🌐 Preparing Authentication Token in Postman

  • Demonstrating how to create and manage an authentication token in Postman.
  • Discussing the importance of handling token expiration in dynamic environments.

52:28 📊 Visualizing JSON Response Data in Postman

  • Explaining how to use Postman’s visualization feature to extract specific data from a JSON response.
  • Demonstrating the creation of a template to customize the data presentation in a table format.

59:19 🔄 Data-Driven Testing in Postman

  • Introduction to data-driven testing in Postman.
  • Creating a Post request and preparing JSON data for testing against different scenarios.
  • Example JSON data for multiple test cases with variations in parameters.

01:10:56 📝 Demonstrating data-driven testing using Postman

  • The section discusses data-driven testing using Postman.
  • Postman allows you to use a single request with different sets of data.
  • The example demonstrates how to use a JSON file to provide different data sets for a single request.

01:24:01 🛠️ Fixing an issue with data not being passed to the request

  • Explains an issue where data wasn’t passed correctly to the request.
  • Shows how to set a global variable in Postman to fix the issue.
  • Demonstrates the importance of saving changes to the request script.

01:35:11 🧪 Extending data-driven testing with dynamic JSON templates

  • Extending data-driven testing with dynamic JSON templates in Postman.
  • Shows how to create a JSON template with variables for dynamic data.
  • Demonstrates how to use different data for each iteration of the request.

01:36:05 📝 Discussing data-driven testing in Postman and using different data sets for requests,

  • Demonstrated how to send requests with different data sets and receive responses.

01:37:06 📊 Explaining the importance of using unique data for data-driven testing,

  • Highlighted the need to avoid using the same data for testing, especially for attributes like email.

01:44:12 🗂️ Comparing data sources for data-driven testing – JSON vs. CSV,

  • Showed how to use both JSON and CSV for data-driven testing in Postman.

01:55:20 📦 Sharing resources in Box Drive and discussing how to access shared resources,

  • Mentioned the availability of shared resources and how to access them for further learning and practice.

01:59:43 🧪 Explaining the logic for comparison in Postman tests and data-driven testing,

  • Clarified the logic for comparing data in Postman tests, ensuring that expected and actual data match for successful tests.

02:02:09 🌐 Handling Unformatted JSON Data

  • How to handle incoming data that is not in a pretty format, specifically JSON.
  • Regardless of the complexity of the JSON data, the fundamental concepts and methods remain the same.

02:04:00 📝 Using Templates for Visualizing Response

  • Discussing the use of templates to visualize JSON responses in Postman.
  • The importance of defining specific attributes in the template to focus on essential data and ignore less important information.

02:06:23 💻 Integration with Code

  • How to push the requests shown in the video to the code.
  • The role of environments in Postman and how to set them up for script execution.

02:08:15 🤔 Understanding the Purpose of Scripting in Postman

  • Recap of the key takeaways from the session.
  • Emphasizing the learning aspect of Postman scripting, especially when dealing with workflows and authentication tokens.

07 PM 06 – Bonus Topic Visualize Template For Complex JSON

00:00 📊 Visualizing Data in a Table

  • In this section, the presenter discusses how to visualize data in a table when dealing with API responses.
  • Explains the basics of creating templates for table visualization.

01:08 🧩 Handling Complex JSON Data

  • The presenter delves into handling complex JSON data, especially when dealing with nested arrays and objects.
  • Demonstrates how to extract specific values from deeply nested JSON structures.

02:30 📄 Creating Multiple Tables in Templates

  • Discusses the concept of creating multiple tables in templates to organize and display different data segments.
  • Provides an example of creating two tables for different data extraction requirements.

03:38 🌐Handling Links and Formatting

  • Explains how to handle links in JSON responses and format them for display in the table.
  • Demonstrates the use of HTML attributes to make links more user-friendly in the table.

04:48 📈 Visualizing Complex JSON Responses

  • The presenter showcases the results of visualizing complex JSON responses using the created templates.
  • Highlights that this approach is not limited to simple responses and can be applied to complex JSON data structures as well.

08 PM 07 – Assignment Topic Handle Status Code Test Case At Collection Level

00:00 📋 Introduction to the Assignment

  • Discusses the need to test different Response Codes for various API calls.
  • Mentions writing specific status code tests for each request, leading to redundancy.

01:07 🛠️ Creating Generic Status Code Tests

  • Proposes the idea of creating generic status code tests at the collection level.
  • Demonstrates how to use Postman’s request object to write condition-based status code tests for different HTTP methods (GET, POST, PUT, DELETE, PATCH).

05:05 💡 Optimizing API Workflow

  • Shows how to apply the generic status code tests to API workflows.
  • Explains how to exclude specific status code tests for certain requests using conditional checks based on request names.

09 PM 08 –Pass Array From One Request To Another Request Update Request Body Using Script Handle XML

00:01 🎯 Handling API Response and Dynamic User ID Extraction

  • Learn how to extract user IDs from an API response.
  • Utilize JavaScript techniques to handle and manipulate data within Postman scripts.

11:43 🔄 Dynamically Iterating through User IDs

  • Understand how to dynamically iterate through extracted user IDs without the need for manual intervention.
  • Use the shift method to cycle through the user IDs in an array.

17:08 🔄 Conditional Logic for Request Execution

  • Implement conditional logic to control request execution based on the availability of user IDs.
  • Ensure that requests are executed in sequence, handling all user IDs.

24:04 📊 Analyzing Request Count

  • Demonstrating how to count the number of requests received, which is 10 in this case.
  • Explaining how the requests are numbered and their URL updates.

24:53 🔄 Handling Responses in PUT Call

  • Discussing the response in a PUT call, specifically the name and status.
  • Highlighting that the name changes to “Puja Automation,” and the status becomes “inactive.”

26:08 🔄 Script Use Case and Loop Handling

  • Explaining how to use the script for updating multiple users.
  • Detailing how the script works with a loop to handle various user IDs.

28:05 🔄 Script Use Case – Creating Orders

  • Discussing a scenario where the script can be used to create orders for multiple users.
  • Demonstrating the flexibility of the script for different use cases.

30:25 📝 Modifying Request Body Programmatically

  • Explaining how to programmatically modify the request body in Postman.
  • Covering the use of JSON.parse() to work with the request body as a JavaScript object.

35:29 📝 Adding and Updating Properties in the Request Body

  • Demonstrating how to add and update properties in the request body using JavaScript.
  • Showing how to modify the request body without changing the original template.

38:36 📝 Handling JSON Arrays in the Request Body

  • Explaining how to work with JSON arrays in the request body programmatically.
  • Demonstrating the addition of a JSON array containing multiple user addresses.

48:02 📜 Explanation of updating request body with a JSON array

  • Demonstrates updating a request body with a JSON array.
  • Discusses using JavaScript and JSON.stringify to achieve this.

52:15 📝 Discussing when and why to use this method

  • Explains the scenario where updating request bodies dynamically is useful.
  • Gives an example of creating multiple APIs with different parameters.

58:22 🌐 Handling XML requests and converting them to JSON

  • Demonstrates how to handle XML requests in Postman.
  • Explains converting XML responses to JSON for easier handling and manipulation.

01:11:55 📊 Storing Inactive User IDs in an Array

  • Storing inactive user IDs in a JavaScript array.
  • Using the “push” method to add IDs to the array.
  • Demonstrating how to access and display the stored IDs.

01:13:21 🛠️ Validating Data and Asserting

  • Exploring the process of validating and asserting data in Postman scripts.
  • Comparing expected data with actual data from responses.
  • Demonstrating how to perform assertions on data.

01:15:56 🔄 Handling XML Data

  • Explaining the process of working with XML data in Postman.
  • Converting XML to JSON for easier manipulation.
  • Navigating and extracting data from the JSON object.

01:17:46 🤔 Advanced Postman Scripting

  • Discussing the use of Postman for advanced scripting tasks.
  • Emphasizing the importance of learning advanced Postman features.
  • Preparing for more complex scenarios and script development.

01:36:03 🚀 Explaining the use of prerequisites in Postman,

  • Prerequisites help manage scenarios where tokens or data need to be reused.
  • Running collections and handling scenarios more efficiently.

01:40:13 🧐 Troubleshooting response formatting in Postman,

  • Addressing issues with response format.
  • Debugging and ensuring the correct format of data in Postman.

01:53:12 🌐 Setting and accessing variables in Postman,

  • Setting variables at different levels: local, collection, and environment.
  • Clarifying variable access within the workspace and collections.

10 PM 09 – API KEY Authorization vs Authentication OAuth1 0 vs OAuth2 0 Flickr API OAuth1 0 Workflow

00:01 🔑 Introduction to API key authentication

  • API keys are a simple form of authentication.
  • They are provided by the API provider and are unique to each user.
  • You include the API key in your requests, and it’s essential for accessing the API.

03:15 🔑 Using API keys in Postman

  • Demonstrates how to use an API key in Postman for making API requests.
  • Shows how to store the API key as an environment variable for better management.
  • Explains that the API key should be passed as a query parameter, as per the API documentation.

11:05 🔑 Basic authentication with username and password

  • Discusses basic authentication, where you provide a username and password.
  • Explains the process of converting the username and password into an encoded string.
  • Shows how to use basic authentication in Postman and mentions the use of the “btoa” JavaScript method.

15:16 🔑 Managing API tokens at the collection level

  • Demonstrates how to set authentication at the collection level in Postman.
  • Shows how to use a Bearer token and manage it through an environment variable.
  • Highlights the advantage of setting authentication at the collection level for consistency across requests.

20:59 🔑 Automatically inheriting authentication settings

  • Explains how Postman automatically inherits authentication settings from the collection level.
  • Demonstrates that requests within the collection do not need to specify authentication headers separately.
  • Emphasizes the convenience and efficiency of this approach for managing multiple API requests.

21:53 🔑 Understanding OAuth 1.0 and OAuth 2.0

  • OAuth 1.0 and OAuth 2.0 are authentication protocols used in APIs.
  • OAuth 1.0 is mostly deprecated, and APIs have migrated to OAuth 2.0 for improved security and simplicity.

27:04 🔑 OAuth 1.0 Flow

  • OAuth 1.0 involves a complex flow with multiple parties, including the user, client (app), and the data provider (authorization server).
  • Temporary request tokens, approved request tokens, and permanent access tokens are used in the flow.

36:57 🔑 OAuth 2.0 Flow

  • OAuth 2.0 simplifies the authentication process, making it easier to implement.
  • It involves the user, client (app), and the data provider (authorization server) but with fewer complex tokens.

45:48 🕵️‍♂️ Explanation of OAuth 1.0 and OAuth 2.0 Flow

  • Detailed explanation of the OAuth 1.0 and OAuth 2.0 authentication flows,
  • Key steps involved in the OAuth authentication process, such as user consent, authorization code, and access token.

54:57 📜 Authentication vs. Authorization

  • Clear distinction between authentication and authorization,
  • Examples illustrating the difference between these two security processes.

01:07:05 🌐 Practical Application of OAuth 1.0

  • Demonstrating the practical usage of OAuth 1.0 for authentication,
  • Exploring the creation of an application and obtaining consumer keys and secrets from Flickr API.

01:09:51 🛠️ Understanding OAuth 1.0 Workflow

  • OAuth 1.0 workflow involves several steps, including obtaining a request token, user authorization, and exchanging the request token for an access token.
  • It’s crucial to pass consumer key and consumer secret in the initial request.
  • The consent or authorization from the user is a crucial part of the process.

01:16:49 🔑 Handling Consumer Key and Secret

  • In OAuth 1.0, the consumer key and consumer secret are essential for authentication.
  • These keys are provided by the developer or API provider and must be used to generate temporary and permanent tokens.
  • Users don’t generate these keys; they are supplied by the developer.

01:28:07 🔄 Exchanging Request Token for Access Token

  • After obtaining a temporary request token and user authorization, the final step is exchanging the request token for an access token.
  • This step involves providing the access token URL, the temporary token, token secret, and a verifier.
  • The verifier is obtained during the user’s consent process, and it’s a crucial security measure.

01:31:24 ✅ Testing the Permanent Token

  • Once you have the access token (permanent token), you can authenticate requests to the API.
  • In this example, the “flicker.test.login” API is used to check if the permanent token allows access to further APIs.
  • This step ensures that the authentication process was successful.

01:33:56 🗂️ Understanding OAuth 1.0 Workflow

  • OAuth 1.0 has a three-step process: Request token, Consent, and Exchange.
  • It requires manual consent, making full automation challenging.

01:36:03 📚 Parsing Non-JSON Response

  • Demonstrates using Postman’s collection API for parsing query parameters in a non-JSON response.
  • Simplifies handling parameters and setting environment variables.

01:43:09 🔄 Handling Environment Variables

  • Shows how to set environment variables in Postman to store authentication tokens and secrets.
  • Explains the need for environment variables in subsequent API calls.

01:45:05 🚀 Completing the OAuth 1.0 Workflow

  • Illustrates the complete OAuth 1.0 workflow, from obtaining the request token to accessing the Flickr API.
  • Emphasizes the manual consent step and the necessity of the verifier.

01:56:56 🗓️ Token Expiry and Final Access Token

  • Discusses the token’s expiration, usually set by the service (e.g., Flickr).
  • Emphasizes that OAuth 1.0 is a one-time setup for obtaining the final access token.

01:59:02 🛠️ Configuring OAuth Expiry Time

  • Explains how to request an increase in token expiry time for the QA environment.
  • Highlights that these steps are for the initial setup and not manual testing.
  • Mentions that OAuth 1.0 is mostly outdated in favor of OAuth 2.0 and JWT Bearer.

02:00:52 🤷‍♂️ Considering Advanced Topics

  • Discusses the option to skip advanced topics like OAuth 1.0 in API testing.
  • Emphasizes the value of understanding these topics for interviews and setting oneself apart from others in the field.

02:01:46 🙌 Audience’s Interest in Learning

  • Acknowledges the audience’s interest in learning and continuing to cover advanced topics.
  • Encourages practical implementation and real-world understanding to stand out in the industry.

02:02:13 💼 Value of Practical Implementation

  • Recognizes the challenges of finding practical examples online.
  • Emphasizes the practical implementation of the concepts in Postman.
  • Relates to the experience in the Selenium training and the importance of hands-on learning.

11 PM 10 – Additional Video How To Create Flickr Client App Generate Consumer Key Consumer Secret

00:00 🧭 Overview of the Flickr API and Account Creation

  • To access the Flickr API, you need to create an application and obtain a consumer key and secret.
  • The process involves signing up for a Flickr account, creating a non-commercial app, and acknowledging their terms.

02:13 🤖 Creating an App and Obtaining Consumer Key and Secret

  • Within Flickr Services, you can create an app and apply for a non-commercial key.
  • You provide app details, such as the name and purpose, to get your consumer key and secret.

04:16 🗝️ Using the Consumer Key and Secret in Postman

  • After obtaining your consumer key and secret, you use them in Postman for API requests.
  • The consumer key and secret are set as environment variables in Postman for ease of use.

06:04 🔄 Requesting a Temporary Token

  • The first API requestis to obtain a temporary token (request token) using the consumer key and secret.
  • The temporary token is necessary for the OAuth 1.0 authentication process.

08:08 🤝 Allowing Access and Obtaining Verifier

  • The user must manually approve access and provide a verifier, which is necessary for the next step.
  • The OAuth verifier is essential for authorizing the request.

09:56 🔄 Exchanging Temporary Token for Permanent Access Token

  • The final step involves exchanging the temporary token (request token) for a permanent access token.
  • The access token is used to make authenticated requests to the Flickr API.

12:40 ✅ Successful Completion and Next Steps

  • After obtaining the permanent access token, you can now use it to interact with the Flickr API for various purposes.
  • This marks the completion of the OAuth 1.0 authentication process.

12 PM 11 – Twitter Oauth 1.0 Pin OOB OAuth2.0 Wokflow JWT Token

00:02 🤖 Explanation of OAuth 1.0

  • OAuth 1.0 has three steps: Request Token, Authorization, and Token Exchange.
  • Request Token is a temporary token used to initiate the process.

03:42 🛡️ Twitter’s OAuth 1.0 with PIN code

  • Twitter supports OAuth 1.0, and they mention that it’s almost deprecated.
  • They explain the steps required to obtain access using OAuth 1.0, including the use of a PIN code.

17:02 💼 OAuth 2.0 Overview

  • OAuth 2.0 is a more streamlined and lighter authentication process compared to OAuth 1.0.
  • In OAuth 2.0, the authorization server immediately grants access after user consent without a verifier.

24:13 🔐 Understanding OAuth 2.0 Workflow

  • Explanation of OAuth 2.0 and its components, including the client, user, and authorization server.
  • Discussion of OAuth 2.0 flow and the concept of consent in the 2.0 flow.

28:18 📱 Automating OAuth 2.0 with Postman

  • Demonstrating how to automate the OAuth 2.0 process using Postman.
  • Setting up environment variables and capturing the access token for use in subsequent API requests.

30:10 🚀 Practical Example: OAuth 2.0 with Amadeus API

  • Applying the OAuth 2.0 workflow to a practical example with the Amadeus API.
  • Creating a new app, generating an access token, and using it to make API requests.

48:50 🔒 Explains the need to create an app for backend testing in OAuth flows.

  • Backend testing requires creating an app to obtain client credentials.
  • Client ID, client secret, API key, and API secret are necessary for testing.

49:33 📜 Discusses using Postman to programmatically send requests. -Demonstrates how to use the Postman pm.sendRequest method for making HTTP requests.

  • Highlights the need to specify the method, headers, and body for the request.

50:07 💻 Explains how to create and configure an OAuth 2.0 app in Postman.

  • Describes setting up an OAuth 2.0 app in Postman, including the URL and request method.
  • Emphasizes the importance of specifying the correct headers and body parameters.

52:27 🧩 Demonstrates programmatically obtaining an access token and setting it as an environment variable.

  • Explains how to extract the access token from the response using response.json().
  • Shows how to create an environment variable to store the access token with the “Bearer” prefix.

54:20 🌐 Discusses the role of OAuth 2.0 in user authorization flows.

  • Clarifies the OAuth 2.0 authorization process, including consent and access token exchange.
  • Highlights the importance of understanding the different OAuth flows.

54:50 📚 Introduces JSON Web Tokens (JWT) and their significance.

  • Provides an overview of JSON Web Tokens and their role in authentication and authorization.
  • Mentions the JWT’s header, payload, and signature components.

59:45 📉 Explains the drawbacks of session ID-based session management.

  • Discusses the limitations of maintaining session IDs in a distributed and load-balanced environment.
  • Highlights the performance and scalability issues with session-based approaches.

01:12:27 🧪 Introduces JWT structure and components.

  • Describes the structure of a JSON Web Token, including the header, payload, and signature sections.
  • Explains the role of each component in a JWT.

01:12:54 📜 Introduction to JWT Tokens

  • JWT tokens consist of three main parts: Header, Payload, and Signature.
  • The Header contains information about the token, such as the algorithm used for hashing.
  • The Payload holds data about the user, including role and expiration date.

01:17:16 🔐 Verification Process of JWT Tokens

  • When a user sends a request with a JWT token, the server verifies its authenticity.
  • The server generates a temporary JWT token by combining the Header, Payload, and a stored secret key.
  • If the client’s JWT token matches the server-generated token, authentication is successful.

01:25:14 🗄️ Managing Secret Keys

  • Each user has a unique secret key for generating and verifying JWT tokens.
  • Secret keys can be securely stored in a separate system like a secret key vault for enhanced security.

01:35:44 🔄 Handling Load Balancers

  • Even when load balancers distribute requests across multiple servers, the verification process for JWT tokens remains effective.
  • The verification process involves generating a temporary JWT token for each request, ensuring authentication across server instances.

01:37:32 🔒 Understanding JWT Token and Server Connection

  • JWT tokens are used for authentication.
  • The server maintains a secret key and connects to a vault for JWT verification.

01:38:18 🔄 Challenges with Session IDs

  • Session IDs can be challenging to manage in load-balanced environments.
  • Session mechanisms can lead to performance issues and user experience problems.

01:40:44 🗝️ HMAC for JWT Security

  • HMAC (Hash-based Message Authentication Code) is used in JWT security.
  • The server maintains the secret key, and JWT tokens are lightweight and secure.

01:45:30 💡 Advantages of JWT Tokens

  • JWT tokens are simple, powerful, and optimized for authentication.
  • Users receive a JWT token after the initial login, reducing the server’s load.

01:47:51 🔄 JWT Token Renewal

  • When a user returns after a period, the server generates a new JWT token.
  • Users continue using the new JWT token for authentication.

01:53:16 🛡️ Testing Secret Key Verification

  • Testers should validate secret key verification for JWT tokens.
  • It ensures that the token creation and validation process is working correctly.

01:57:57 🔐 Understanding JWT Token Validation

  • Websites like JWT.io decode and validate JWT tokens to demonstrate how the process works.
  • They do not create actual JWT tokens but decode and validate the provided token for educational purposes.

13 PM 12 – Postman Important Scripts Examples Headers & Remove Update TimeOut PM Echo APIs Monitors

00:00 📋 Understanding Postman Scripting

  • In this section, the speaker introduces Postman scripting and the importance of working with JSON data.

02:27 📦 Dynamic Data Extraction from Arrays

  • The speaker demonstrates how to dynamically extract data from JSON arrays using Postman scripting, avoiding hard-coded index values.

14:14 ✅ Writing Assertions for Dynamic Data

  • The section covers how to write assertions to validate the dynamically extracted data from arrays, ensuring it meets specific criteria.

19:00 📝 Handling JSON Data with Comments

  • This part explains how to work with JSON data in Postman, including writing comments for documentation within your JSON requests.

22:18 📊 Extracting Target Value from an Array

  • You can fetch the target value from a single array by using a simple method.
  • The index of the array is determined by the size of the array.
  • You can use this method for assertions without writing complex test cases.

25:01 🌐 Validating HTML Response

  • You can use Postman’s built-in functions to validate non-JSON responses like HTML.
  • Example of using PM.expect and PM.response.text to check for specific content within the HTML response.
  • This is helpful for verifying text or elements within HTML responses.

30:22 🧩 Partial JSON Response Validation

  • Demonstrates how to validate a JSON response by checking if it contains specific attributes.
  • Shows how to use PM.expect and JavaScript objects to verify the presence of certain JSON attributes.
  • You can use this technique to ensure that the expected attributes are included in the response.

42:03 🎲 Generating Random Numbers and Strings

  • Explains how to create custom functions for generating random numbers and strings in Postman.
  • These functions can be used to dynamically populate values in your API requests.
  • Demonstrates the flexibility of using custom JavaScript functions in Postman for data generation.

46:49 📜 How to manipulate the request body in Postman

  • Convert the raw request body to a JavaScript object using JSON.parse.
  • Add new attributes or properties to the request body.
  • Demonstrates adding a random number to the request body.

54:16 🕰️ Adding a delay in Postman requests

  • Using set timeout to introduce a delay in the script execution.
  • Useful for scenarios where you need to pause between multiple requests.

01:05:21 🌐 Programmatically adding multiple headers in Postman

  • Creating an array of header key-value pairs and iterating through it to add multiple headers in a single request.

01:10:02 🔄 Updating headersin Postman requests

  • Demonstrates how to update an existing header in a request using the upsert function in Postman.

These sections provide insights into various Postman scripting techniques, including manipulating request bodies, introducing delays, adding multiple headers, and updating existing headers in your Postman requests.

01:11:41 🔧 Updating Request Headers in Postman

  • You can update request headers in Postman to modify header values.
  • You can also delete specific headers if needed.
  • Be aware that some headers, like mandatory ones, cannot be removed.

01:15:28 🌐 Postman Echo APIs for Testing

  • Postman Echo provides sample APIs for testing and development.
  • These APIs offer a range of functionalities, such as fetching the current timestamp, generating specific HTTP response codes, and more.
  • They are useful for developers to quickly test their applications without having to create mock endpoints.

01:23:05 📊 Setting Up API Monitoring in Postman

  • You can set up API monitoring in Postman to regularly run collections and check their performance.
  • Monitors can be configured with various options like environment, run frequency, and notification settings.
  • This feature is useful for keeping an eye on your APIs’ performance and availability.

01:30:08 🧩 Understanding Predefined Headers in Postman

  • Predefined headers are auto-generated by Postman and are essential for making requests.
  • They include headers like user agent, content type, and others that are needed for the tool to interact with APIs.
  • Developers mainly focus on adding custom headers according to API documentation while Postman handles the predefined ones.

01:33:58 🧪 Running Tests with Skip in Postman

  • You can use pm.test.skip in Postman to skip specific test cases.
  • This allows you to temporarily skip tests without commenting them out, making it easy to re-enable them later.

01:35:09 🚫 Failing Tests Deliberately in Postman

  • You can deliberately make a test fail in Postman by using pm.test.fail.
  • This can be useful in certain scenarios, although it’s rare to intentionally fail a test.

01:36:44 🏃 Running Specific Tests in Postman with pm.test.only

  • In Postman, you can use pm.test.only to run a specific test case.
  • This allows you to execute only the selected test, similar to selecting a test case in TestNG.

01:39:28 📜 Mocha and Chai in Postman

  • Mocha is a testing framework, and Chai is an assertion library commonly used with JavaScript-based testing in Postman.
  • Together, Mocha and Chai provide the framework for writing and asserting test cases in Postman.

01:41:08 📦 Handling Dynamic Response Data in Postman

  • You can handle dynamic response data by defining specific keys within the response.
  • This allows you to access and use specific data elements from the response in your tests.

14 PM 13 – Bonus Video How To Send XML Body In Request USing Script XML DataDrivenTest

00:00 🛠️ Creating a Postman request with XML body

  • You can create a Postman request with an XML body programmatically.

02:31 📊 Setting the content type for XML

  • To send an XML body in a Postman request, set the “Content-Type” header to “application/xml.”

05:04 📩 Sending the XML request using Postman scripting

  • Use the pm.sendRequest method in Postman scripting to send a request with an XML body.

09:29 📂 Parameterizing XML data from a CSV file

  • You can parameterize XML data by fetching values from a CSV file and updating the request body accordingly.

13:07 🐛 Fixing a bug in the code

  • When parameterizing values, use replaceAll to ensure all instances of a variable in the XML body are updated correctly.

15 PM 14 – Mocking APIs Schema Validation AJV NewMan Data Driven With File Default HTML Reporting

00:00 🤖 Introduction to Mocking APIs in Postman

  • Understanding the concept of mock servers and API mocking.

02:33 🛠️ Creating Mocking APIs in Postman

  • Creating mock APIs in Postman to simulate behavior.
  • Use cases for creating dummy or sample APIs for testing purposes.

05:18 🔄 Integrating Mocking APIs with Testing

  • Integrating mock APIs into testing scenarios.
  • Creating dummy responses and defining API behavior.

16:07 🔗 Accessing and Using Mocked APIs

  • Accessing and using the mock APIs created in Postman.
  • Demonstrating how to fetch responses from the mock APIs.

19:52 📚 Java Libraries for API Mocking

  • Mentioning Java libraries like WireMock for API mocking in Java.

22:00 📜 Understanding Mocking APIs and Its Importance

  • Mocking is a common mechanism used for service virtualization.
  • You can create mock servers to simulate APIs and define their behavior.

24:05 🛠️ Assignment: Create Mock Server and Dummy APIs

  • Assignment to create a mock server with four dummy APIs: create, retrieve, update, and delete.
  • Specify proper responses for each API, such as 204 for delete, 201 for post, and 200 for put.

31:11 🧩 Understanding JSON Schema Validation

  • JSON Schema validation ensures that API responses adhere to predefined data structures.
  • Key aspects include mandatory fields, type consistency, and avoiding extra attributes in responses.

36:07 🧩 Implementing JSON Schema Validation in Postman

  • Demonstrates the process of using Postman to create and validate JSON schemas.
  • Shows how to utilize AJV (Another JSON Schema Validator) within Postman to validate API responses against a predefined schema.

45:51 📊 Exploring JSON Schema Validation

  • Demonstrating JSON schema validation using Postman and AJV Library.
  • Changing the JSON type from an array to an object for validation.
  • Discussing the importance of schema validation for API contracts.

48:00 🔄 Updating API Schemas

  • Exploring schema validation for an OAuth 2.0 API.
  • Discussing the flexibility of schema templates and default values.
  • Emphasizing the need for clear documentation and schema sharing between development teams.

50:06 🔄 Data-Driven Testing in Newman

  • Demonstrating data-driven testing using a JSON file in Postman collections.
  • Running a collection with external data using Newman, and specifying the data file with the -d or --iteration-data flag.
  • Highlighting the versatility of Newman for test automation.

54:09 📄 Generating HTML Reports with Newman

  • Generating HTML reports with Newman, either using the -r HTML flag or the custom Newman Reporter HTML.
  • Comparing the default HTML report provided by Newman with the more feature-rich HTML Extra report.

Please note that some sections discuss commands that might require installation or configuration.

01:10:59 📊 Generating Reports in Newman

  • Learn how to generate reports in Newman, including HTML extra reports and the default HTML report.

01:11:19 🧾 Default HTML Report vs. HTML Extra Report

  • Understand the difference between the default HTML report provided by Newman and the HTML extra report, which is developed by an external developer.

01:11:32 🌐 Options for Running Collections

  • Explore various options for running collections with Newman, such as specifying the environment, using global variables, and more.

01:11:45 🔀 Iteration Count

  • Learn how to use the -n flag to specify the number of times you want to run the same collection, allowing for multiple iterations.

01:11:59 🚀 Running in Silent Mode

  • Discover how to run collections in silent mode, which prevents Newman from displaying output in the CLI.

01:12:13 🌈 Color Output

  • Understand how to control the display of colors in Newman’s reports, whether you want them on or off.

01:12:27 🕰️ Delay and Timeout

  • Learn how to use flags like -d for delaying requests and set timeout options for better control over your collection runs.

01:12:41 🚫 Disable SSL Validations

  • Discover the -k flag to disable SSL validations, which can be useful when dealing with certificates.

01:12:53 📜 Additional Flags

  • Explore other flags like -cert, -key, and more for advanced options related to client certifications.

01:13:07 🧩 Custom Reports

  • Learn about the possibility of generating custom reports by overriding the -r flag, but be cautious about combining different reports together.

16 PM 15 – Jenkins Setup Newman Jenkins Integration HTML Report Setup Paramterization Scheduling

00:01 🚀 Introduction to Postman Performance Testing

  • Postman can be used for load and performance testing of APIs.
  • Performance testing in Postman involves running collections with multiple virtual users and analyzing the results.

01:10 📈 Running Performance Tests in Postman

  • Running performance tests in Postman involves specifying the number of virtual users and test duration.
  • You can configure parameters like ramp-up period for gradual load increase.

03:03 📊 Analyzing Performance Test Results

  • Postman provides detailed performance test results, including error rate, average response time, and requests per second.
  • You can analyze the results, apply filters, and monitor specific APIs within a collection.

04:55 🛠️ Using Postman for Performance Testing

  • Postman simplifies performance testing without the need for complex scripting.
  • It’s suitable for small to moderate virtual user loads.

07:02 📦 Setting Up Jenkins for Running Postman Collections

  • Jenkins can be used to automate the execution of Postman collections.
  • Jenkins provides a way to integrate Postman collections into your CI/CD pipeline.

09:10 🌐 Accessing Jenkins and Setting Up Jenkins Server

  • Jenkins is a continuous integration tool that can be installed on a server.
  • You need to unlock Jenkins, configure it, and install suggested plugins during the initial setup.

12:36 ⚙️ Configuring Jenkins for Postman Integration

  • To use Jenkins for running Postman collections, you need to configure Jenkins.
  • The Jenkins server can be accessed using the machine’s IP address, not just localhost.

16:18 📥 Downloading and Setting Up Node.js and Newman

  • Node.js and Newman are essential for running Postman collections.
  • You should install the Node.js plugin and set up Newman in Jenkins.

17:41 📂 Setting Up Required Plugins and Publishing Reports

  • Jenkins requires plugins like Node.js and HTML Publish to work with Postman collections and publish reports.
  • HTML Publish is useful for sharing Postman collection execution reports.

21:26 🏗️ Creating a Jenkins Job for Postman Collections

  • You need to create a Jenkins job (project) to run Postman collections.
  • Within the job, you can define shell scripts to execute collections and publish reports.

21:53 🏗️ Jenkins Setup Newman Jenkins Integration HTML Report Setup Paramterization Scheduling

  • Setting up Newman run commands in Jenkins.
  • Configuring Postman collections and scheduling in Jenkins.
  • Discussing the need to specify file paths for Postman collections in Jenkins.

26:05 🧰 Jenkins Initial Setup and Plugin Installation

  • Creating an admin user in Jenkins.
  • Installing required Jenkins plugins, such as Node.js plugin and HTML publisher plugin.
  • Configuring Node.js and necessary npm packages.

31:27 📋 Creating a Freestyle Jenkins Job for API Testing

  • Setting up a new Jenkins project for API testing.
  • Configuring Jenkins job settings, including description and build steps.
  • Preparing the shell command for running Postman collections in Jenkins.

37:25 🚀 Running Jenkins Job and Viewing Console Output

  • Executing the Jenkins job for running API tests.
  • Checking the console output for the test execution.
  • Verifying the successful execution of the Jenkins job.

43:03 📊 Troubleshooting Broken HTML Reports in Jenkins

  • Identifying issues with generated HTML reports in Jenkins.
  • Exploring solutions to fix broken HTML reports.
  • Discussing content security policy (CSP) settings for Jenkins.

45:22 🚀 Jenkins Setup and Security Policies

  • DevOps teams manage Jenkins security policies.
  • Adding scripts to Jenkins can impact other projects and may be denied.
  • An extension called Content Security Policy (CSP) can help mitigate this issue.

47:10 📊 Publishing HTML Reports

  • Configuring and publishing HTML reports in Jenkins.
  • Using parameters to make report generation more flexible.
  • Demonstrating how to create a new job with parameters for different collections.

48:06 🔄 Reusing Parameters for Collection and Environment Names

  • Parameterizing the job to allow different collection and environment names.
  • Choosing collection and environment names when running the job.
  • Enabling flexibility in job execution for various scenarios.

01:09:37 ⚙️ Configuring Choice Parameters in Jenkins

  • Configuring Choice Parameters for collection and environment selection.
  • Creating dropdown options for different collections and environments.
  • How to select the right collection and environment for your Jenkins job.

01:16:18 📧 Email Notification Configuration in Jenkins

  • Setting up email notifications for Jenkins job status.
  • Configuring recipient email addresses and content type.
  • Discussing the need for a company SMTP server for email notifications.

01:31:01 ☁️ Jenkins on Cloud and File Access

  • Addressing file access when Jenkins is on a different machine or in the cloud.
  • Options for handling JSON files when Jenkins is running on a remote machine.
  • Considerations for moving JSON files between machines in a Jenkins setup.

01:32:36 ⚙️ Setting up Jenkins and Postman integration

  • Jenkins integration with Postman and Newman.
  • Options for handling collections in Jenkins, including using Git.

01:33:58 🕐 Configuring Jenkins and Postman for integration

  • Configuring Jenkins for running Postman collections.
  • Ensuring Java 11 or 17 is installed for Jenkins to work properly.

01:36:39 🧪 Troubleshooting Postman scripts

  • Discussing issues related to running Postman scripts and sharing API data.
  • Ensuring proper Java versions for Jenkins and Postman integration.

01:49:46 🚧 Handling Mock APIs for Development and Testing

  • Managing mock APIs for testing and development.
  • Discussing the use of mock APIs for various testing environments.

01:57:31 ⏰ Adding delays between API executions

  • Exploring options for adding delays between API executions in a collection.
  • Using delays to address issues related to API response times.

01:58:36 🕒 Prerequisites and Sleep Function in JavaScript

  • JavaScript sleep function and its use in test automation.

02:00:26 🌐 Cheerio API for Parsing HTML

  • Using Cheerio API to parse HTML responses in Postman.
  • Demonstrating how to extract specific data from an HTML response.

02:03:13 💼 Preparing for Pure HTTP Client Automation

  • Discussing the use of pure HTTP client automation with Java.
  • Mentioning resources and sample code for HTTP client automation.

02:08:34 🛠️ Importance of Practicing with Postman

  • Emphasizing the importance of practicing with Postman for test automation.
  • Encouraging thorough understanding and practice with Postman before moving on to Rest Assured.

Rest Assured Tutorial

17 RA 01 – Project Setup GET API With BDD Non BDD

00:01 🚀 Setting up the project structure

  • Create a collection with folders for products, carts, and users.
  • Implement CRUD operations (GET, ADD, UPDATE, DELETE) for each folder.
  • Include an authentication API for user login.

01:10 🌐 Understanding API details

  • Examine API endpoints, HTTP methods, and request bodies.
  • Differentiate between POST and GET calls.
  • Note that the APIs are for practice, and no real data is stored in a database.

03:03 🔐 Analyzing authentication in API

  • Review a user login API.
  • Identify the HTTP method (POST), the required JSON body, and potential authentication methods.
  • Examine JSON Web Tokens (JWT) for authentication.

08:58 🔧 Setting up the Java environment

  • Ensure you have at least JDK 8, JDK 11, or JDK 17.
  • Use Eclipse or IntelliJ as your IDE.
  • Set up a Maven project and add necessary dependencies for Rest Assured and TestNG.

11:03 📝 API testing essentials

  • Emphasize the importance of checking status codes, response bodies, and response headers.
  • Discuss the use of cookies in API testing.
  • Mention the need to write test cases for validating API responses.

17:01 📋 Training roadmap

  • Outline the training plan, starting with core features.
  • Mention that the course will cover advanced topics like frameworks, DevOps integration, and reporting.
  • Clarify that Cucumber is not needed for API testing in this context.

20:54 🧩 Setting up the Maven project

  • Create a Maven project in Eclipse, specifying group and artifact IDs.
  • Adjust the Java version in the POM file.
  • Add the Rest Assured dependency to the project.

These are the main sections of the provided video transcript, each focusing on distinct topics related to API testing with Rest Assured and Java.

22:00 🛠️ Setting up the project structure

  • You can define the project scope for test cases or libraries.
  • Updating the project with Maven helps manage dependencies.

23:21 📦 Adding Rest Assured and HTTP Client dependencies

  • Rest Assured is a library built on top of HTTP Client for API automation.
  • HTTP Client is a versatile Java API used in various projects, including Selenium.

25:00 📚 Adding TestNG dependency

  • TestNG is used for designing and executing test cases.
  • Choosing the appropriate version of TestNG and adding it to the project.

27:19 📂 Creating package structure for test cases

  • Organizing your project into packages, such as separating test cases from utility classes.
  • Establishing a package structure for test cases and utilities.

29:13 🌐 Preparing the API request

  • Using Rest Assured’s given method to create a request specification.
  • Setting the base URL and adding headers for the API request.

36:36 🚀 Executing the API request and obtaining the response

  • Making a GET request with Rest Assured and receiving the API response.
  • Storing the response in a variable for further processing.

41:02 ✅ Validating the status code

  • Asserting the actual status code with the expected value (200) to ensure the API call’s success.
  • Implementing assertions for validation.

42:42 📋 Fetching and printing the status message

  • Extracting the status message from the API response.
  • Displaying the status message on the console.

43:57 📄 Viewing the API response body

  • Printing the API response body for inspection.
  • Using the prettyPrint method to display the response content.

44:41 🔍 Explaining how to pretty print the response in Rest Assured.

  • Using response.prettyPrint() to format JSON, XML, or HTML responses for better readability.
  • Demonstrating that the pretty print format resembles what is seen in tools like Postman.
  • Highlighting the importance of using pretty print for easier response inspection.

46:09 📊 Fetching and printing response headers in Rest Assured.

  • Explaining how to retrieve specific headers using response.header("HeaderName").
  • Demonstrating how to extract and print the “Content-Type” header from the response.
  • Introducing the concept of fetching all headers with response.headers() and storing them in a list for further analysis.

48:12 🧾 Iterating and printing all response headers in Rest Assured.

  • Utilizing a for-each loop to iterate through the list of headers.
  • Demonstrating how to access and print both the header name and its corresponding value.
  • Emphasizing that not all headers need to be validated, and you can focus on the relevant ones.

56:08 🧰 Adding query parameters to a REST API call in Rest Assured.

  • Discussing the importance of query parameters and how to use them in API requests.
  • Showing how to add query parameters to the request URL using request.queryParam("parameterName", "parameterValue").
  • Highlighting the benefits of adding query parameters programmatically for flexibility and maintainability.

01:04:16 🚀 Adding query parameters using a HashMap in Rest Assured.

  • Introducing the concept of using a HashMap to manage multiple query parameters.
  • Demonstrating how to create a HashMap with key-value pairs for query parameters.
  • Using request.queryParams(queryParamsMap) to add multiple query parameters to the API request, making the code more maintainable and scalable.

01:07:50 📋 Rest Assured Non-BDD Approach

  • Introduction to Rest Assured non-BDD approach.
  • Using static methods for given, when, and then in Rest Assured.
  • Chaining methods to create a concise and readable API test.

01:19:10 🧩 BDD Approach in Rest Assured

  • Exploring the BDD (Given-When-Then) approach in Rest Assured.
  • Using static methods for given, when, and then in a BDD context.
  • Chaining methods to create a structured and readable API test with assertions.

01:32:28 🛠️ Overview of Rest Assured

  • Rest Assured is a framework for API testing in Java.
  • It provides a readable and builder pattern approach for API testing.

01:32:55 📜 Building Assertions with Rest Assured

  • Assertions in Rest Assured are used to validate API responses.
  • Examples of assertions include checking the status code, body content, and specific attributes.

01:34:21 🧩 Working with Response Body

  • Explains how to work with the response body in Rest Assured.
  • Demonstrates how to access and validate specific elements within the response body.

01:39:39 🕵️ Using Hamcrest Matchers

  • Introduces Hamcrest matchers for more complex assertions.
  • Shows how to use Hamcrest matchers to validate array size in the response.

01:43:43 🚫 Hard Assertions in Rest Assured

  • Explains the concept of hard assertions in Rest Assured.
  • Highlights that in hard assertions, if one assertion fails, the following assertions are not executed.

01:44:16 🚀 Preferences in API Testing

  • Discusses the preference for using Rest Assured over other testing approaches.
  • Mentions that Rest Assured offers a readable format for API testing.

01:49:03 📚 Practice and Assignment

  • Encourages practice and assigns an exercise to create a collection.json file.
  • Mentions that the assignment should be submitted for review.

01:52:27 🤔 Rest Assured vs. Postman

  • Opens a discussion about the choice between Rest Assured with Java and Postman with JavaScript.
  • Emphasizes the importance of being familiar with both tools.

18 RA 02 – GETAPI BDD With PathParam QueryParam FetchJsonBody JsonArray Data Provider Extract Method

00:02 📝 Introduction to testing REST APIs using RestAssured BDD style

  • The video introduces testing REST APIs with RestAssured using BDD style.
  • Explains the concept of method chaining and Builder pattern in RestAssured.
  • Demonstrates a basic API test for a GET request with various assertions.

01:35 📊 Adding headers in a REST API test

  • Shows how to add headers to a REST API test using RestAssured.
  • Specifically, demonstrates adding an authorization header to a test.
  • Emphasizes the importance of using the header in BDD-style test cases.

09:29 🔄 Testing a GET request with query parameters in BDD format

  • Explains how to test a GET request with query parameters in BDD format using RestAssured.
  • Demonstrates adding query parameters such as “limit” to the request.
  • Highlights the flexibility of RestAssured in constructing the request URL with query parameters.

17:27 📝 Extracting data from a JSON response using RestAssured’s JsonPath

  • Introduces the concept of extracting data from JSON responses in a REST API test.
  • Demonstrates the use of RestAssured’s JsonPath to extract specific values from a JSON response.
  • Shows how to extract the ID of the first product from a JSON response.

22:43 📚 Extracting Data Using JsonPath in Java

  • Demonstrating how to extract data from JSON using JsonPath in Java.

24:28 📊 Extracting Pricing Information

  • Explaining how to extract pricing information from JSON data.
  • Discussing the choice between using float or double data types for storing prices.

26:52 🔄 Accessing Nested Data in JSON

  • Demonstrating how to access nested data in a JSON structure using JsonPath.
  • Retrieving the count value from a nested structure.

30:14 📋 Fetching Multiple Data Sets

  • Explaining how to fetch multiple sets of data, such as IDs, titles, rates, and counts, and store them in separate lists.

39:15 📝 Iterating Through Multiple Lists

  • Demonstrating how to iterate through multiple lists simultaneously to access and print their values.

45:26 🚫 Handling Incompatible Data Types

  • Identifying and addressing issues related to incompatible data types when storing data in lists, like trying to store an integer in a list of floats.
  • Highlighting potential errors and the need to ensure data types match correctly in your code.

47:22 🚗 Handling a type mismatch error in Java

  • Integer cannot be cast to float error explained.
  • Using object class to handle various data types in a list.
  • Explicitly specifying the generic type for a list.

49:04 🧮 Handling JSON responses and extracting data

  • Fetching data from a JSON response using RestAssured.
  • Extracting values from a JSON object.
  • Using the extract method to simplify value extraction.

54:57 📬 Using extracted values for further API requests

  • Storing extracted values for reuse in subsequent API calls.
  • Demonstrating how extracted values can be used in API request headers.
  • Preparing for future demonstrations on POST requests with RestAssured.

01:11:17 🛣️ Handling Path Parameters in API Requests

  • Introduction to working with path parameters in API requests.
  • Upcoming examples using path parameters for specific API calls.
  • Preparing to explore circuit data in the next demonstration.

01:11:57 🔍 Understanding Path Parameters vs. Query Parameters

  • Path parameters in REST API,
  • Query parameters in REST API,
  • Differentiating path and query parameters.

01:13:09 🛣️ Parameterizing Path Parameters in Postman

  • How to define path parameters in Postman,
  • Using colons to create path variables,
  • Modifying path parameters in Postman.

01:15:30 🔄 Automating Path Parameters with TestNG Data Providers

  • Data-driven approach using TestNG data providers,
  • Creating a data provider method,
  • Parameterizing pathparameters in test methods.

01:36:21 🧐 Running tests with a data provider for path parameters

  • Demonstrating the use of a data provider for path parameters.
  • Highlighting the flexibility of data providers to supply variable values.

01:37:21 📦 Predefined schema and the robustness of API endpoints

  • Emphasizing the stability of API endpoints due to predefined schemas.
  • Discussing the unlikelihood of sudden changes in well-defined APIs.

01:38:34 💼 Avoiding unnecessary data maintenance in Excelsheets

  • Advising against maintaining data in Excel sheets for API testing.
  • Encouraging boundary value analysis within the test script.

01:43:47 🧐 Understanding sequential query parameters

  • Clarifying the role of query parameters and their sequence in URLs.
  • Explaining the flexibility of query parameter order.

01:44:21 🖥️ Homework assignment: Extracting circuit IDs

  • Assigning a task to collect circuit IDs from the JSON response using Rest Assured.
  • Encouraging students to practice and enhance their skills.

02:03:30 🔄 Updating a Patch Call

  • Correcting a patch call for updating a resource.
  • Removing unnecessary query parameters from the request.
  • Using the correct JSON body for the patch call.

02:05:34 🗑️ Deleting a Product

  • Demonstrating how to send a delete request to delete a product.
  • Explaining that this is a fake API with no actual database, so it returns a success message but doesn’t delete anything.
  • Discussing the null response for a deleted item in this non-functional API.

02:07:29 🆕 Adding a New Card

  • Troubleshooting issues with adding a new card by correcting the JSON body.
  • Ensuring that values are enclosed in double quotes in the JSON body.
  • Successfully adding a new card to the system.

02:09:25 📚 Documentation on Methods

  • Discussing the availability of documentation for the methods used in the session.
  • Suggesting referring to official Java documentation for detailed method information.
  • Mentioning the possibility of creating a cheat sheet for commonly used methods in Selenium.

19 RA 03 – Request Specification Builder POST Call API With JSON String File OA

00:01 🛠️ Request Specification and Response Specification in Rest Assured

  • Request and Response Specification can be created in Rest Assured to streamline API testing.

01:06 🌐 Request Specification

  • Request Specification can be created using the RequestSpecBuilder class.
  • It allows you to set the base URI, content type, and headers for your API requests.

06:45 🧩 Building Request Specification

  • You can build a Request Specification using the RequestSpecBuilder class.
  • The build method returns a Request Specification object, and it’s not a case of top casting.

15:15 🚀 Advantages of Request Specification

  • Request Specifications help in creating reusable code for API requests.
  • You can easily manage changes in the request specification in one place, reducing redundancy.

16:13 📝 Response Specification

  • Response Specifications can be created using the ResponseSpecBuilder class.
  • They allow you to define expected status codes, content types, and headers for API responses.

21:07 🧩 Building Response Specification

  • You can build a Response Specification using the ResponseSpecBuilder class.
  • It allows you to define expectations for status codes, content types, and headers.

22:29 🧱 Using Response Specification in Tests

  • You can use Response Specifications in your API tests to ensure consistent validation of responses.
  • Response Specifications help reduce redundant code for common response validation tasks.

24:28 📝 Explanation of using response specifications

  • Creating and using response specifications in Rest Assured.
  • Reducing code duplication and boilerplate by defining response specifications.

25:59 🛠️ Creating a 401 Unauthorized response specification

  • Creating a response specification for a 401 Unauthorized response.
  • Reusing response specifications for different test cases.

30:29 📋 Creating a response specification with a response body

  • Demonstrating how to create a response specification that includes expectations for the response body.
  • Using Hamcrest matchers to validate the response body.

36:34 📝 Combining request and response specifications

  • Combining request and response specifications to create more meaningful and reusable test cases.
  • Using utility methods to maintain and share specifications across the project.

49:26 📋 Extracting JSON Path and Post Calls

  • Demonstrating how to extract JSON path data from a response.
  • Discussing the use of JSON path for extracting data from responses in API calls.
  • Preparing for upcoming examples involving JSON path usage.

50:46 🧩 JSON Path and Post Call with JSON File

  • Explaining the concept of JSON path in real-time scenarios.
  • Introducing a post call with JSON data and discussing its simplicity compared to hardcoded values.
  • Suggesting the use of JSON files to supply data for API calls.

52:30 📂 Creating a JSON File for API Data

  • Demonstrating how to create a JSON file to store data for API requests.
  • Explaining the importance of maintaining non-Java files like JSON in a “resources” folder.
  • Providing guidance on organizing project resources for easy access.

58:09 ✅ Writing an End-to-End API Test

  • Discussing the process of writing an end-to-end API test for adding a user.
  • Emphasizing the importance of combining multiple steps into a single test case for an end-to-end workflow.
  • Showing how to create and use a JSON file to supply data for API requests and asserting responses.

01:13:27 📝 Overview of creating a dynamic email for testing purposes.

  • Discusses creating random email addresses for testing.

01:14:20 📊 Explanation of the structure of a Postman request.

  • Details the components of a Postman request, including token, headers, and request structure.

01:15:06 🛠 Building an OAuth 2.0 test in Java for authentication.

  • Demonstrates how to construct a test case for OAuth 2.0 authentication, including form data and headers.

01:17:32 🧪 Writing a test for getting flight information.

  • Details the steps to create a test case for retrieving flight information, including headers and query parameters.

01:29:26 📋 Extracting data from a response in Java.

  • Explains how to extract specific data from a JSON response using JSON path in Java.

01:36:00 📦 Implementing a reusable method to get an OAuth token.

  • Demonstrates creating a reusable method for obtaining an OAuth token and using it in subsequent API calls.

Sure, I’ve divided the transcript into sections of information based on the common theme. Here are the sections with timestamps and key takeaways:

01:39:17 🔍 Understanding Rest Assured Concepts

  • Rest Assured simplifies API testing by allowing you to create request and response specifications.

01:42:37 📜 Request Specification and Response Specification

  • Request and Response specifications in Rest Assured help you define common request and response attributes, saving you from redundant code.

01:43:33 🌐 Building Request Specifications

  • Request specifications can be created with Rest Assured, containing common attributes like authentication tokens and content types.

01:44:29 📈 Creating Reusable Response Specifications

  • Response specifications can be set up to check common response attributes, such as HTTP status codes or response content.

01:49:46 🔄 Creating Tests with Request and Response Specifications

  • You can create tests using both request and response specifications, reducing repetitive code in your test methods.

01:52:05 🧩 Solving Import Issues

  • Ensure you have the correct static imports for Rest Assured methods to avoid errors.

01:56:08 📊 Handling Large Data Sets

  • When dealing with large data sets, store them in a list and use assertions or JsonPath syntax to validate specific values.

02:04:58 📊 Understanding JSON path syntax

  • Explaining JSON path syntax and usage,
  • Demonstrating how to navigate and extract data from a JSON response using JSON path.

02:07:03 🕵️ Troubleshooting response output

  • Discussing the limitations of console output for large responses,
  • Suggesting debugging techniques like printing the method name for better analysis.

20 RA 04 Request Response Spec POST Call With POJO Jackson Serialization JayWay JsonPath Expressions

00:00 📝 Understanding Request and Response Specifications

  • Combining request and response specifications for code simplification and reusability.
  • Creating a Java class for an example.

03:40 📊 Automating Serialization with POJO

  • Introduction to Plain Old Java Object (POJO) for serialization.
  • Creating a POJO class for a request body and explaining its use.
  • How to serialize an object using POJO for JSON requests.

23:08 💡 Setting up credentials for a request

  • Creating and setting up credentials with a username and password.

24:10 🧩 Troubleshooting JSON Serialization Error

  • Encountering a JSON serialization error and attempting to resolve it by adding Jackson API to the classpath.

25:56 📝 Correcting Variable Names

  • Identifying and fixing a mistake where variable names in a POJO class didn’t match the JSON keys.

29:44 🛠️ Creating a Random Email ID Generator

  • Demonstrating the creation of a method for generating random email IDs using a timestamp or UUID.

32:04 🌐 Using a POJO Class for API Requests

  • Discussing the use of a POJO class to represent and interact with API requests, highlighting the advantages of getters for validation.

47:59 🔍 Understanding Jackson Library in API Testing

  • Jackson is a mandatory library for API testing.
  • Using Jackson for serialization in REST Assured.

49:11 🌐 Introduction to JBa Rest Assured API

  • JBa Rest Assured API, also known as JsonPath Query Language (JQL), is introduced.
  • It simplifies the verification of complex JSON objects in API testing.
  • Solving complex JSON object queries using JBa Rest Assured.

50:29 📋 Examples of JsonPath Query Language

  • Examples of using JBa Rest Assured’s JsonPath query language.
  • Retrieving specific data from a JSON object.
  • Using query expressions and operators for JSON object queries.

54:15 🧐 JsonPath Query Language Syntax

  • Understanding the syntax of JsonPath query language.
  • Exploring different query expressions.
  • Practice for writing JsonPath queries for specific JSON data.

01:09:17 🛠️ Practical Examples with Complex JSON

  • Demonstrating practical examples with a complex JSON response.
  • Writing JsonPath queries to extract specific data from the JSON.
  • Hands-on practice with JsonPath query language for advanced JSON data validation.

01:11:27 📊 Exploring JsonPath Expressions

  • JsonPath expressions allow you to extract data from JSON structures.
  • You start with a dollar sign ($) to indicate the root of the JSON.
  • Expressions can be used to filter, navigate, and extract specific data from complex JSON documents.

01:13:52 🌟 Filtering JSON Data

  • You can use JsonPath to filter JSON data based on specific conditions.
  • For example, fetching all rates less than three can be expressed as $[?(@.rating.rate < 3)].
  • JsonPath makes it easy to extract data meeting certain criteria.

01:17:18 🧐 Combining Multiple Criteria

  • JsonPath allows you to combine multiple criteria for filtering data.
  • For instance, selecting titles where the category is “jewelry” can be expressed as $[?(@.category == 'jewelry')].title.
  • This helps you extract specific information from complex JSON structures efficiently.

01:21:26 💼 Complex Filtering

  • Complex JsonPath expressions can be used to filter data based on multiple conditions.
  • For example, selecting titles and categories where the rate is between 2 and 4 can be expressed as $[?(@.category == 'women's clothing' && (@.rating.count >= 100 && @.price < 10))].[title, category].
  • JsonPath allows you to handle intricate data filtering requirements.

01:34:20 🌐 Escaping Special Characters

  • JsonPath expressions may require escaping special characters.
  • Using a backslash () can help escape characters like single quotes to ensure accurate data retrieval.
  • Understanding how to escape characters is essential for precise JsonPath expressions.

01:36:15 🔀 Using “OR” Operator

  • JsonPath allows you to use the “OR” operator, denoted as ||, to combine conditions.
  • You can select data that meets one condition or another.
  • Understanding how to use the “OR” operator in JsonPath is important for more advanced filtering.

21 RA 05 – JSON Path Query With Rest Assured Create POJO Deserialization GET Call Lombok POJO

00:01 📝 Introduction to using JsonPath with Rest Assured

  • Understanding the basics of JsonPath and its role in Rest Assured.

03:01 📊 Adding the JsonPath Library for Advanced Queries

  • Exploring the need to add the JsonPath library to Rest Assured for advanced query capabilities.

05:33 🧭 Creating and Using JsonPath Queries in Code

  • Demonstrating how to use JsonPath queries within Java code to extract specific data from JSON responses.

08:34 📈 Retrieving Lists of Data Using JsonPath

  • Working with JsonPath to retrieve lists of data, such as a list of countries from a JSON response.

11:41 🏁 Handling More Complex JsonPath Queries

  • Dealing with complex JsonPath queries, including filtering data based on conditions and extracting specific information.

16:34 📜 Storing and Using Data from JsonPath Queries

  • Storing and using data obtained from JsonPath queries, including handling different data types like float and string.

21:47 🧩 Choosing the Right Data Type for JsonPath Results

  • Discussing the importance of choosing the appropriate data type when storing results from JsonPath queries, considering collections and maps.

22:28 📝 Understanding JSON Path Query for Rest Assured

  • JSON Path query allows you to fetch specific data from a JSON response.
  • Demonstrating the need to escape double quotes to specify keys explicitly in JSON.

25:13 🛠️ Iterating and Extracting Data from JSON

  • Exploring how to iterate through a JSON list using a for-each loop.
  • Discussing data types in JSON responses and handling them appropriately.

28:00 📖 Efficient Handling of Multiple Keys in JSON Path

  • Learning to extract data with multiple keys in JSON Path queries.
  • Demonstrating that you can handle any number of keys in JSON responses with ease.

30:48 🧩 Simplifying JSON Response Extraction with JSON Path

  • Highlighting the simplicity of extracting specific data using JSON Path queries.
  • Emphasizing the importance of understanding JSON Path for API testing.

37:13 🗂️ Practice and Importance of JSON Path in Interviews

  • Stressing the significance of practicing JSON Path for job interviews in API testing.
  • Encouraging practice with real-world scenarios to excel in interviews.

44:11 🌐 Serialization and Deserialization in API Testing

  • Explaining the concepts of serialization and deserialization in API testing.
  • Discussing the importance of libraries like Jackson for JSON serialization and deserialization.

47:32 📚 Explanation of the need for serialization and deserialization in REST API calls,

  • In a GET call, deserialization is required to convert JSON responses to POJOs.

50:06 🏗️ Creating a POJO (Plain Old Java Object) for response mapping,

  • Steps for creating a POJO class for mapping JSON responses.

52:11 🧩 Creating a nested inner class for handling JSON objects within the response,

  • Explains the need for creating a nested inner class for handling JSON objects within the response.

01:02:57 🤖 Using the Object Mapper class for deserialization,

  • Demonstrates the use of the Object Mapper class for deserialization of JSON responses.

01:06:16 🛡️ Handling JSON arrays in response and iterating through them,

  • How to handle JSON arrays in responses and iterate through them to extract data.

01:12:14 🧐 JSON to POJO Deserialization and Advantages

  • Discusses deserialization of JSON data into POJOs.
  • Highlights the advantage of deserialization for assertions.
  • Mentions the relevance of covering both JSON to POJO deserialization and JSONPath queries.

01:15:00 🧩 When to Use Serialization vs. JSONPath

  • Explains when to use JSON to POJO deserialization.
  • Highlights that deserialization isn’t needed for GET requests.
  • Introduces the concept of using serialization if required for request bodies.

01:18:28 🏗️ Simplifying POJO Creation with Lombok

  • Introduces Lombok as a tool for simplifying POJO creation.
  • Demonstrates how to use Lombok annotations like @NoArgsConstructor, @AllArgsConstructor, and @Data.
  • Explains how Lombok reduces the boilerplate code for POJO classes.

01:26:13 🏗️ Lombok Builder Pattern

  • Introduces the Lombok Builder pattern for creating POJOs.
  • Discusses the @Builder annotation.
  • Explains how to use Lombok to simplify POJO creation with builder patterns.

01:37:25 🧐 Understanding the use of Pozo (POJO) in API testing

  • Pozo (POJO) is used for more readable and structured assertions.
  • Pozo allows you to validate data directly without using JsonPath queries.

01:39:27 🤔 When to use serialization and deserialization in API testing

  • Serialization is used when you send data in the request, such as in POST or PUT requests.
  • Deserialization is used when you receive data in the response, such as in GET requests.

01:41:26 📦 Creating separate Pozo classes for different API requests

  • Create separate Pozo (POJO) classes for different API requests, especially when the response data varies.
  • This approach helps maintain a clear schema for the response data.

01:43:37 🧐 When to use serialization and deserialization in API testing based on the request type

  • Serialization is used when you send data in the request (e.g., POST or PUT).
  • Deserialization is used when you receive data in the response (e.g., GET).
  • The choice depends on whether you are dealing with request data or response data.

01:49:54 🤯 Benefits of using Pozo (POJO) for assertions

  • Pozo (POJO) allows for more readable and structured assertions.
  • It provides a clear schema for the response data.
  • Pozo can simplify the validation of data elements.

01:58:57 🧐 Choosing between creating Pozo or List of String for API response

  • Create a Pozo (POJO) class for response elements with a key-value structure.
  • For simple lists of values without keys, use a List of String.

02:00:19 🤔 Handling mandatory and non-mandatory fields in request Pozo classes

  • Create request Pozo classes that include all fields, both mandatory and non-mandatory.
  • Use annotations and manipulate the request data based on your testing needs.

02:01:46 🧐 Using annotations to handle different variations of request data

  • Use annotations to control the behavior of request data.
  • You can create a single request Pozo class and adjust it using annotations to handle various scenarios.

02:02:02 🧐 Discussion on JSON attributes and serialization

  • Explained the need to control attributes in JSON.

02:03:16 🤔 Question about custom annotations for schema validation

  • Clarified that schema validation is not provided by Lombok but by Jackson annotations.

02:04:13 📢 Importance of using established libraries like Lombok and Jackson

  • Emphasized the stability and popularity of libraries like Lombok and Jackson for Java development.

02:15:19 🧐 Troubleshooting Lombok issues in Eclipse

  • Assisted with resolving Lombok-related issues in Eclipse.

02:21:42 🐞 Troubleshooting issues with assertions in API testing

  • Addressed a query about assertions when comparing API data with database values.

02:27:37 🛠 Explanation of at the rate data annotation for Getters and Setters

  • Discussed the usage of the @Data annotation for generating Getters and Setters in Java classes.

22 RA 06 Create User POST With POJO Lombok Builder Pattern Complex JSON To POJO Lombok Builder Pattern

00:01 📚 Introduction and Recap

  • Recap of the previous session on creating a basic POJO class and using Lombok for reducing boilerplate code.
  • Mention of an upcoming example that involves serialization and deserialization with the Builder pattern.

01:21 🏗️ Creating a User POJO Class

  • Discussion on creating a User POJO class using Lombok annotations for convenience.
  • Deciding not to include an ID field in the class to simplify the structure.

12:42 🧪 Writing a Test for Creating a User

  • Initiating a test method for creating a user with Rest Assured.
  • Setting up the request, including headers, and the JSON body.
  • Sending a POST request and extracting the response, along with the user’s ID.

20:04 🧪 Testing User Retrieval

  • Preparing a test to retrieve a user’s data using a GET request.
  • Parsing the response and deserializing it into a User object using Jackson ObjectMapper.
  • These sections provide a structured breakdown of the video content, emphasizing key takeaways and actions performed in each part.

23:59 🏭 Understanding the Serialization and Deserialization Process

  • Discusses the concept of serialization and deserialization in Java.
  • Highlights the importance of understanding when these processes are used in API testing.
  • Explains the need for deserialization in POST requests.

30:10 🧩 Serialization vs. Deserialization in API Testing

  • Distinguishes between serialization and deserialization in the context of API testing.
  • Emphasizes that serialization is crucial for POST requests, while GET requests often don’t require it.
  • Demonstrates where serialization and deserialization are implemented in the code.

33:39 🧰 Implementing the Builder Pattern in Java

  • Introduces the Builder pattern and its significance in Java.
  • Explains how to use the Lombok Builder annotation to simplify object creation.
  • Demonstrates creating objects with the Builder pattern for improved readability.

38:19 🚀 Using the Builder Pattern for Object Creation

  • Demonstrates how to create objects using the Builder pattern in Java.
  • Shows the advantages of this approach for object initialization.
  • Compares different methods of object creation in Java.

45:11 🎯 Handling Complex JSON Data for API Testing

  • Discusses the challenge of handling complex JSON data in API testing.
  • Introduces the concept of creating a POJO class structure to map JSON data.
  • Explains the need to create nested classes for complex JSON structures.

49:16 🏢 Creating POJO Classes for JSON Data Mapping

  • Demonstrates the creation of POJO classes to map complex JSON data.
  • Shows the structure with a main class and nested inner classes for categories and tags.
  • Highlights the importance of modeling the JSON data accurately for API testing.

49:29 🏗️ Creating a Master POJO Class

  • Creating a Master POJO class named “Pet” with various annotations like @Data, @AllArgsConstructor, @NoArgsConstructor, and @Builder.
  • Defining attributes such as ID, category, name, photo URLs, and tags for the Pet class.

52:28 🧪 Creating Test for Pet Object without Builder Pattern

  • Writing a test method for creating a Pet object without using the Builder pattern.
  • Demonstrating how to set up and serialize a Pet object with various attributes.
  • Deserializing the response and extracting data from the Pet object.

01:11:55 📜 Handling Deserialization and Data Extraction

  • Utilizing Jackson’s ObjectMapper to deserialize the response into a Pet object.
  • Extracting information from the Pet response, including ID, name, status, category, photo URLs, and tags.

01:16:38 🧰 Discussing the advantages of using Pozo Lombok and Builder pattern.

  • Pozo Lombok simplifies the serialization and deserialization process.
  • Builder pattern is a powerful way to create complex objects with ease.

01:17:54 🧩 Implementing the Builder pattern to create a complex object.

  • Using the Builder pattern with Lombok to construct a pet object.
  • Demonstrating how to set various attributes of the pet using the Builder pattern.

01:23:59 🏗️ Finalizing the Builder pattern implementation.

  • Completing the pet object using the Builder pattern.
  • Highlighting the importance of consistent serialization and deserialization in real-time projects.

01:41:42 🔄 Converting XML to Java Objects

  • Demonstrates converting XML to Java objects.
  • Highlights encapsulation and getter-setter methods.
  • Encourages creating objects manually before generating.

01:42:25 🔍 Understanding Package Name Customization

  • Discusses customizing package names.
  • Explains the flexibility of modifying package names.
  • Encourages user control over package names.

01:42:55 🧐 Jackson Annotation and Variable Mapping

  • Explains Jackson’s JsonProperty annotation.
  • Details how to map variables with different names.
  • Demonstrates the importance of matching JSON and Java variable names.

01:44:55 🛠️ Object Mapper and Deserialization

  • Introduces the Object Mapper from Jackson API.
  • Discusses its role in deserialization.
  • Emphasizes the significance of Object Mapper in JSON processing.

01:46:21 🚀 Adding Lombok Library in Eclipse

  • Explains how to add the Lombok library in Eclipse.
  • Highlights the plugin installation process.
  • Recommends Eclipse users to practice during the weekend.

01:47:45 ⚙️ Fixing Builder Pattern Issue

  • Diagnoses and fixes a Builder pattern issue.
  • Instructs adding the JsonInclude annotation.
  • Demonstrates resolving the problem of null values in requests.

23 RA 07 Put Delete APIs Schema Validation Post With Different Body TEXT HTML XML JAVASCRIPT MultiPath

00:00 📚 Overview of upcoming topics

  • Recap of previous topics, including get, post, JSON, and serialization.
  • Introduction to using put and delete methods for API operations.

02:18 🛠️ Using PUT method to update a user

  • To update a user, you first need the user’s ID, obtained from a previous POST request.
  • Demonstrates how to use the PUT method to update a user’s information using the user’s ID.
  • Explains the importance of not creating a new user object but using setters to update the existing user.

11:24 🏗️ Handling ID with JSON Include Annotation

  • Discusses how to handle the default ID value (null) when creating a user object.
  • Explains the use of the JSON Include annotation to ignore properties with null values when creating the user object.

16:21 🏭 Building User Objects with Lombok Builder Pattern (Homework)

  • Encourages viewers to explore using the Lombok builder pattern for creating user objects.
  • Advises against using the builder pattern for updating users and suggests using setters for updates.

19:22 🚀 Implementing the Delete User Flow

  • Introduces the process of deleting a user through the delete API.
  • Describes the steps, including creating a user, obtaining the user’s ID, and then using a delete request.

23:49 🔗 Verifying User Deletion with a GET Request

  • Explains how to verify the deletion of a user by making a GET request after performing a delete operation.
  • Discusses the need to fetch the same user and shows a snippet of code for this verification step.

24:01 💡 Creating a schema for schema validation

  • Create a schema JSON file for schema validation, ensuring it’s in the classpath.

46:53 💡 Troubleshooting schema validation issues

  • Explained how to resolve schema validation issues when the schema file isn’t in the classpath.

48:16 💡 Validating schema for user data

  • Demonstrated schema validation for user data in a GET request, verifying that it matches the specified schema.

49:45 🚀 Exploring Different Schema Types

  • Understanding schema types, including array and object.
  • Creating a schema for the “get user” endpoint and changing the schema type from “create user” to “get user.”

52:32 📝 Sending Text, HTML, JavaScript, XML, and More in Requests

  • Exploring how to send various types of data in API requests, including text, HTML, JavaScript, and XML.
  • Demonstrating how to set the appropriate content type for different data types in API requests.
  • Discussing the importance of specifying the correct content type for the data being sent in requests.

59:00 📄 Handling Raw XML Data

  • Sending and receiving XML data in API requests.
  • Specifying the content type for XML data in API requests.
  • Demonstrating the use of raw XML as a payload in an API request using RestAssured.

01:11:41 📤 Working with Form Data in API Requests

  • Exploring how to work with form data in API requests.
  • Setting the content type to “multipart/form-data” for form data requests.
  • Discussing the structure of form data and how to include key-value pairs as part of the request.

These sections cover different aspects of working with API requests, including schema types, handling various data types, dealing with XML data, and working with form data in HTTP requests.

01:15:50 📑 Explaining Multi-Part Request in REST Assured

  • Multi-part requests in REST Assured allow you to send both files and form data in a single request.
  • You can specify the name, file key, and file content for each part of the multi-part request.
  • When working with files, you need to use the File class to provide the file’s path.

01:19:13 📄 Understanding Binary File Uploads

  • Binary file uploads in REST Assured involve sending a single file as a binary stream.
  • The Content-Type header depends on the type of the file being uploaded (e.g., “application/pdf” for PDF files).
  • You can specify the file to upload using the File class, and you may need to set a custom Content-Type header.

01:29:21 🌐 Working with URL-Encoded Form Data

  • URL-encoded form data is used in REST Assured for scenarios like OAuth 2.0 token retrieval.
  • You can set the Content-Type header to “application/x-www-form-urlencoded” or “application/www-form-urlencoded” for such requests.
  • This content type is used for sending data in key-value pairs, and it’s essential for OAuth 2.0

24 RA 08 XMLPATH XMLAPIs Deep Scanning All Types Of Auth APIs BAsic Preemptive Digest JWT APIKEy All

00:01 📚 Overview of XML validation in REST Assured

  • Introduction to validating XML responses in REST Assured.
  • Discussion on the importance of handling XML data in APIs.
  • Mention of practical scenarios where XML responses may be encountered.

02:32 🛠️ Creating a test class for an XML API

  • Demonstrating the process of creating a test class for XML API testing.
  • Setting up the base URI and performing a simple GET request.
  • Storing the response and preparing for XML validation.

05:02 🖇️ Extracting and validating circuit names

  • Extracting circuit names from the XML response using XML Path in REST Assured.
  • Storing circuit names in a list for further validation.
  • A brief discussion on the importance of using lists for multiple data points.

09:07 🎯 Retrieving circuit IDs as attributes

  • Demonstrating how to extract circuit IDs, which are attributes in XML, using XML Path.
  • Highlighting the distinction between fetching text and attributes.
  • Providing insights into constructing XML queries for attribute-based data.

14:02 🌐 Advanced XML querying for specific data

  • Introducing more complex XML querying techniques, including deep scanning.
  • Explanation of the “double star” (**) for deep scanning in XML.
  • Constructing a query to find specific data, such as locality, based on conditions.

22:11 🚀 Fetching specific data and data type handling

  • Fetching specific data like locality based on conditions using XML Path.
  • Conversion of the result to a string for proper data type handling.
  • A demonstration of querying multiple attributes within an XML structure.

23:08 🌐 Understanding Deep Scanning of XML in Groovy

  • Deep scanning of XML, finding elements based on conditions.
  • Groovy scripting used for this, not Java.
  • Demonstrating the concept with an example.

24:24 🌐 Fetching Attributes from XML in Groovy

  • Retrieving attributes from XML using Groovy scripting.
  • Demonstrates fetching latitude and longitude attributes.
  • Shows how to create separate queries for different attributes.

28:08 🌐 Combining Conditions in XML Path Queries

  • Combining conditions using logical operators like “or” in XML path queries.
  • Fetching data based on multiple criteria.
  • Demonstrates getting data for different countries and localities.

32:35 🌐 Retrieving Specific Data with XML Path Queries

  • Using XML path queries to extract specific data.
  • Demonstrates fetching circuit names based on conditions.
  • Shows how to retrieve data efficiently using queries.

37:23 🌐 Introduction to OAuth Types in REST Assured

  • Discussing various OAuth types in REST Assured.
  • Mentioned basic OAuth, OAuth 2, API key, and JWT authentication.
  • Preparing to demonstrate basic OAuth in the next section.

44:43 🌐 Implementing Basic OAuth Authentication

  • Implementing Basic OAuth authentication in REST Assured.
  • Utilizing username and password to authenticate.
  • Extracting and understanding the JWT token.

47:36 🌐 Breaking JWT Token into Parts

  • Explaining how to break a JWT token into its parts: header, payload, and signature.
  • Demonstrates splitting the token using a dot as a separator.
  • Provides insights into handling JWT tokens in interviews.

48:02 🌐 Comparing Basic Authentication in Selenium

  • Comparing Basic Authentication in REST Assured with Selenium.
  • Discusses using username and password for authentication.
  • Mentions a Heroku app example for Basic Authentication.

01:13:30 📊 Introduction to AOR Report in Rest Assured

  • AOR (Allure Report) for Rest Assured provides detailed reports without extensive configuration.
  • AOR generates reports for request-response interactions, including HTTP status codes and graphs.
  • A separate project is available for AOR reports, and it requires minimal setup and no additional plugins or listeners.

01:14:11 🔌 Setting Up AOR Report and Server

  • AOR is a server-based report, and you need to run it on your local machine.
  • If you need to refresh the report, you should stop the server and restart it to get the latest results.
  • Ensure that AOR is installed by checking its version with “allure –version.”

01:15:13 🛠 Installing Allure for AOR

  • Instructions for installing Allure on Mac and Windows machines are provided.
  • Mac users can use a simple command, while Windows users can install Allure using Scoop, a special installer.
  • Allure is recommended for generating stable and mature reports for test cases.

01:18:45 📝 Automated JWT Handling in Rest Assured

  • Rest Assured simplifies JWT (JSON Web Token) handling by automatically managing username and password.
  • You don’t need to handle tasks like Base64 encoding or HS256; the server takes care of it.
  • This feature streamlines authentication processes in Rest Assured.

Rest Assured Framework Tutorial

25 RA FW 01 Design HLD Folder Structure Rest Client GET POST PUT DELETE API TESTS

00:02 📝 Designing an End-to-End Framework for REST Assured

  • Designing a framework for REST Assured involves segregating code into various components.
  • The key components include a REST client, test classes, POJO (Plain Old Java Object) classes, configuration properties, data providers, and utilities.
  • Creating a structure for maintaining base URLs, tokens, and other configuration data.

02:23 🛠️ Building a REST Client for HTTP Methods

  • Developing a REST client class that handles various HTTP methods like GET, POST, PUT, and DELETE.
  • The client class creates request specifications for making API calls.
  • These methods return responses, which will be used for validation in test classes.

04:13 🧪 Creating Test Classes for API Testing

  • Writing test classes that use the REST client to perform API tests.
  • Test methods are annotated with @Test and include assertions for validation.
  • Test classes consume data from data providers and may use POJO classes for data representation.

07:30 📑 Maintaining Configuration Properties

  • Storing base URLs, tokens, and other configuration properties in a config.properties file.
  • Using a separate Java class to read and initialize these properties.
  • Ensuring flexibility and configurability for the API automation framework.

10:28 📊 Reading Data from Excel Sheets

  • Implementing an Excel utility using Apache POI to read test data from Excel sheets.
  • Data providers in test classes can retrieve data from Excel files.
  • Enhancing data-driven testing capabilities.

15:08 🔄 Creating Test Runners with TestNG XML Files

  • Building TestNG XML files for organizing and executing test suites.
  • Configuring parallel execution using TestNG XML.
  • Running tests collectively, ensuring efficient automation.

16:03 🏃‍♀️ Understanding Parallel Execution

  • Discussing the pros and cons of parallel execution in API automation.
  • Exploring TestNG’s parallel execution options.
  • Advising on the best practices for parallel testing in API automation.

17:44 🔨 Utilizing Utility Classes

  • Utilizing utility classes like Excel utilities for reading Excel data.
  • Creating custom utility classes for generating random strings and performing string manipulations.
  • Enhancing code reusability and maintainability with utility classes.

20:00 ❗ Handling Exceptions in API Automation

  • Implementing a custom exception class by extending the RuntimeException class.
  • Using custom exceptions to handle unexpected situations in API automation code.
  • Ensuring robust error handling for a more reliable automation framework.

21:26 🛠️ Setting Up a Maven Project for REST API Testing

  • Creating a Maven project for REST API testing.
  • Designing the high-level architecture of the framework.
  • Discussing the importance of the pom.xml file in a Maven project.

24:32 📁 Organizing Test Classes in SRC Test Java

  • Structuring the test layer by creating packages and classes.
  • Creating test classes for specific API endpoints.
  • Ensuring a clear separation between test classes and base classes.

26:52 📜 Creating TestNG XML Test Runners

  • Creating TestNG XML runners for organizing and executing test suites.
  • Planning for regression and other test suites within the framework.
  • Setting up the configuration for test execution.

34:28 🛡️ Defining Constants and Custom Exceptions

  • Creating a package for constants to store framework-related constants.
  • Maintaining HTTP status codes as constants in an API status class.
  • Designing custom exceptions and extending runtime exceptions for error handling in the framework.

37:46 📊 Utilizing Utility Classes for Testing

  • Creating utility classes to handle tasks like working with Excel data and generating random email addresses.
  • Organizing utility classes in a separate package for easy access and maintainability.
  • Preparing for data-driven testing and other utility-based functionalities.

These sections provide an overview of setting up a REST API testing framework, organizing test classes, creating TestNG XML runners, defining constants, custom exceptions, and preparing utility classes for testing.

43:38 🚀 Explaining the creation of a basic request specification

  • You can create a basic request specification for a GET call by setting the base URI and authentication header.

54:39 🛡️ Overloading the request specification method for different use cases

  • Overloading the method to handle different request types, such as GET, POST, etc.
  • Demonstrating the use of a header map for additional headers.

58:42 📋 Handling query parameters in the request specification

  • Overloading the method to handle query parameters in the request specification.
  • Demonstrating the use of query parameters with a map.

01:02:23 🌐 Creating a method to set the request content type

  • Creating a utility method to set the content type for the request specification.
  • Handling different content types with a switch case and converting to lowercase.
  • Providing a default case for unsupported content types.

01:06:09 🛠️ Explanation of custom exceptions and generic utility in API testing,

  • Creating a custom exception class for handling various content types.
  • Developing a generic utility method for adding authorization headers, setting content type, and handling request bodies.

01:12:11 🤓 Discussion on encapsulation and method accessibility,

  • Using private methods for internal utility functions.
  • Exploring the advantages of encapsulation in method design.

01:19:57 📚 Overloading methods for flexibility in API testing,

  • Overloading methods to handle different combinations of headers, query parameters, and request bodies in HTTP calls.
  • Demonstrating flexibility in method design for diverse testing scenarios.

01:25:14 🌐 Creation of HTTP methods for API testing,

  • Developing methods for HTTP calls like GET, POST, PUT, PATCH, and DELETE with various parameters.
  • Ensuring dynamic handling of different use cases in API testing.

01:29:28 📝 In this section, the instructor explains how to navigate and understand the structure of a REST client class in Java.

  • You can access public methods of a REST client class, but not private methods.
  • Understanding the blueprint of the REST client class is essential for API automation.

01:31:06 📝 In this section, the instructor demonstrates how to write a test case for a GET request using a REST client.

  • Creating a test method using TestNG annotations.
  • Making a GET request and adding an authorization header.

01:35:25 📝 This section focuses on writing assertions for the GET request in the test case.

  • Demonstrating assertion of the response status code.
  • Emphasizing the separation of utility and assertion responsibilities.

01:38:14 📝 Here, the instructor explains how to write a test case for a specific GET request using a REST client.

  • Demonstrating how to create a URL with a specific user ID in the test.
  • Writing assertions for the response to verify the specific user.

01:43:08 📝 In this section, the instructor demonstrates how to create a test case for a GET request with query parameters.

  • Generating a query parameter using a HashMap and adding it to the request.
  • Writing assertions to verify the response.

01:48:39 📝 The instructor begins to explain how to write a test case for a POST request to create a user.

  • Setting up the REST client for a POST request.
  • Preparing a user object to send as the request body.

01:50:01 📝 In this section, the instructor shows how to send a POST request to create a user and extract the response.

  • Creating a user object and sending it as the request body.
  • Extracting the user ID from the response forfurther use.

01:51:20 📝 The instructor continues by explaining how to send a GET request to retrieve the user created in the previous step.

  • Using the user ID obtained from the POST request to construct the GET request.
  • Writing assertions to verify the response, including the user ID.

01:54:12 🐛 Handling Duplicate Authorization Header

  • Duplicate authorization headers can cause a 400 Bad Request error.
  • The issue arises when the same REST client is used for both the POST and GET requests.
  • Consider handling this bug by checking if the authentication header is already added to the request.

01:55:48 📚 Conclusion and Encouragement

  • Rest client methods, such as GET, POST, PUT, and DELETE, are essential in any REST API testing framework.
  • The session concludes with an encouragement to practice and revise the concepts.
  • The importance of customizing code to create a wrapper over RestAssured is highlighted.

01:57:02 🧰 Creating a Custom Wrapper

  • Creating a custom wrapper over RestAssured allows for better code management and customization.
  • The session emphasizes the use of method overloading to handle variations in method parameters.
  • Comparisons are made with custom wrappers in Selenium for handling web elements.

01:58:30 🌐 Handling Multiple Services in One Framework

  • Managing multiple services within the same framework with different base URLs is possible.
  • Suggests maintaining base URLs for different services and adjusting the configuration accordingly.
  • The same framework can be utilized for various services with proper configuration.

01:59:28 🚑 Fixing Duplicate Token Header Issue

  • Explains the bug causing duplicate authentication headers when using the same specification builder.
  • The bug is attributed to the common specification builder used for both POST and GET calls.
  • Suggests fixing the bug by checking if the authentication header is already present in the specification builder.

02:01:14 🚀 Non-Static Rest Client Methods

  • Non-static methods are preferred in Rest client utilities to make them independent and thread-safe.
  • The decision to use non-static methods allows for executing tests in parallel without issues related to thread safety.
  • Static methods might cause problems when dealing with multi-threading environments.
  • These sections provide a breakdown of the video content with key takeaways and timestamps.

26 RA FW 02 Properties File Base Test No Auth APIs TestNG XML Allure Report Extent Report

00:00 🚀 Introduction to the framework and past developments,

  • Recap of previous work on creating a basic design, including a restaurant and a test for it.
  • Identification of an issue related to authentication header duplication during API calls.

05:29 🔗 Solving the authentication header issue,

  • Explanation of how to resolve the problem by creating separate instances of the REST client for different API calls.
  • Demonstrating the solution’s effectiveness by running the test and confirming its success.

10:13 🌐 Configuring dynamic base URIs,

  • Discussing the need for dynamic base URIs based on different environments and applications.
  • Incorporating the base URI configuration within the REST client and demonstrating how to set it dynamically.

16:13 🔐 Managing authentication tokens,

  • Integrating token management by reading authentication details from a properties file.
  • Implementing a Configuration Manager to handle the properties file and retrieve the token for use in REST client requests.

19:22 🛠️ Refactoring and inheritance in test classes,

  • Refactoring test classes to utilize inheritance from a base test class.
  • Demonstrating how to inherit variables and methods, such as the REST client, from the parent class.

23:20 🔍 Explanation of access modifiers in Java

  • Default access modifier restricts access outside the package.
  • The protected keyword allows access in child classes.
  • Protecting variables for inheritance in child classes.

25:10 🧐 Sequence of TestNG annotations and method execution

  • Overview of TestNG annotation sequence.
  • Initialization process in TestNG before test method execution.

26:06 🤔 Understanding object references in Java

  • Explaining how one object can have multiple references.
  • Clarifying the concept of object references in Java.

32:07 🌐 Using TestNG XML to manage base URLs

  • Discussing the use of TestNG XML to manage base URLs.
  • Parameterizing base URLs for different test classes in TestNG.

36:25 💼 Parameterizing base URI with TestNG Parameters

  • Implementing parameterization using TestNG Parameters annotation.
  • Reading base URI from TestNG XML and using it in the test.

27 RA FW 03 Duplicate Auth HAndle Refactoring Rest Client OAuth2 Http Status Constant

00:01 📚 Overview of Framework Features

  • The framework supports multiple endpoints and base URLs.
  • It provides generic HTTP methods like get, post, put, and delete.
  • Test cases such as get user and create user were introduced.

04:20 🔒 Solving Duplicate Authentication Header Issue

  • A feature flag for adding authentication headers is introduced.
  • By using a feature flag, duplicate authentication headers are prevented.
  • The code is modified to handle authentication headers more effectively.

12:24 🔄 Handling Rest Client Object Creation

  • The importance of creating separate Rest Client objects for different test cases is emphasized.
  • The use of @BeforeMethod annotations to ensure each test method has its own Rest Client object is demonstrated.
  • This approach prevents null pointer exceptions and ensures tests run correctly.

23:30 🧪 Running Multiple Test Cases

  • Multiple test cases, including those with separate Rest Client objects, are successfully executed.
  • The approach ensures that test cases can run together without conflicts or errors.
  • The benefits of using this testing methodology for maintaining test stability and preventing issues are highlighted.

24:13 🛠️ Discussing the issue of reusing the same Rest Client object for multiple test cases,

  • Explains the problem of using a single Rest Client object for multiple test cases,
  • Describes the impact of reusing the Rest Client on URL and query parameters.

28:00 🧠 Implementing a solution for OAuth 2.0 integration in API automation,

  • Discusses the need to add OAuth 2.0 authentication to the test,
  • Describes how to create a generic method for getting an access token,
  • Explains the usage of TestNG parameters to supply values like service URL, grant type, client ID, and client secret.

44:56 🚀 Implementing a test using the generic method for OAuth 2.0,

  • Demonstrates how to use the generic method for OAuth 2.0 authentication in a test,
  • Shows how to create a separate Rest Client object for the test,
  • Explains how to call the generic method and handle query parameters.

48:32 🛠️ Explaining code structure and import

  • Importing Java classes and explaining the code structure.
  • Discussing the usage of query parameters.

49:01 🔐 Setting up authentication for API request

  • Demonstrating the setup of authentication for making API requests.
  • Discussing the use of authentication tokens.

49:32 🗺️ Creating a header map for API requests

  • Creating a header map for API requests and adding an authorization token.
  • Discussing the structure of the header map.

51:26 🌐 Extracting and logging the API response

  • Extracting and logging the API response using REST Assured.
  • Discussing the use of the JSON path to extract specific data.

52:13 🧩 Handling different API requests

  • Discussing the approach to handling multiple API requests with separate REST clients.
  • Managing base URLs for different APIs.

54:18 📊 Running multiple API tests

  • Demonstrating the execution of multiple API tests using REST Assured.
  • Managing tokens for individual test cases.

57:25 🛠️ Refactoring code for configuration management

  • Discussing the need to refactor code to manage configuration parameters.
  • Considering options like config.properties or command line arguments for configuration.

59:09 🐍 Handling dynamic data in test cases

  • Addressing the challenge of handling dynamic data in test cases.
  • Exploring the benefits of generating new tokens for each test case.

01:04:16 🧹 Refactoring to eliminate hard-coded values

  • Identifying and addressing hard-coded values in test cases.
  • Demonstrating the use of constant variables to store common values.

01:11:05 📝 Using constant variables for API endpoints

  • Replacing hard-coded API endpoint values with constant variables.
  • Enhancing code maintainability by storing common endpoints in the base test class.

01:13:04 🧩 Setting Service URLs and Removing Hard-Coded Values

  • Creating variables for service endpoints.
  • Replacing hard-coded values with variables.
  • Discussing the importance of data providers for test data.

01:15:36 📚 Introduction to Enum Constants for HTTP Status Codes

  • Explaining the purpose of enums in Java.
  • Creating an enum for HTTP status codes.
  • Using enum constants for standard status codes in REST API testing.

01:17:44 💡 Implementing Enum Constants in Test Code

  • Demonstrating how to use enum constants for status codes in test code.
  • Refactoring test code to replace hard-coded status codes with enum constants.

01:26:32 📝 Using Data Providers for Test Data

  • Introducing the concept of data providers in testNG.
  • Creating a data provider method for test data.
  • Using data provider to parameterize test methods.

01:31:18 🚀 Running Tests in Parallel for Faster Execution

  • Explaining the benefits of running tests in parallel.
  • Configuring testNG for parallel test execution.
  • Demonstrating how parallel execution can save time in API testing.

01:38:07 🧐 Troubleshooting API Failures and Authentication

  • Troubleshooting API issues through logs,
  • The importance of logging for debugging,
  • Properly explaining authentication methods (OAuth 1.0 and OAuth 2.0) during interviews.

01:40:56 📝 Logging Best Practices

  • Using log statements effectively in test code,
  • Customizing log output using Log4j,
  • Reducing log verbosity for specific information needs.

01:42:04 🤓 Handling Null Values in Serialization

  • Addressing the importance of non-null annotations in POJOs,
  • Preventing serialization issues by handling null values effectively.

01:49:55 💡 Debugging and Troubleshooting

  • Addressing issues related to missing configuration files,
  • Handling errors in the test framework caused by missing dependencies,
  • Resolving serialization issues by ensuring a default constructor is present in the POJO class.

01:54:43 🔍 Identifying and Fixing Syntax Errors

  • Debugging and fixing issues caused by unintended spaces in code,
  • Addressing HTTP error code 422 (Unprocessable Entity) in test execution.

28 RA FW 04 – JSON XPATH Validator DataDriven With Excel POI RunTest USing Maven

00:01 📋 Introduction to the need for a JSON Path Utility

  • The need to create a JSON Path utility to simplify the extraction of data from JSON responses.

02:50 🧩 Creating a JSON Path Validator Utility

  • Creating a JSON Path Validator utility with methods to read JSON paths, including a generic method with a type parameter for various return types.

17:03 🛠️ Using the JSON Path Validator Utility

  • Demonstrating how to use the JSON Path Validator utility to extract data from a JSON response and perform assertions.

23:18 📑 Explaining the use of read list method for JSON array

  • Use readList method for JSON arrays.
  • Store JSON arrays in a list of strings for handling different expressions.

25:04 🛠️ Implementing validation for JSON path queries

  • Using assertions to validate JSON path queries.
  • Demonstrating how to check if a list contains a specific value.

27:14 📚 Preparing utilities for JSON and XPath validation

  • Creating utility classes for JSON and XPath validation.
  • Discussing the benefits of reusable utilities in test automation.

29:07 🗂️ Discussing the possibility of creating an XPath validator

  • Considering the creation of an XPath validator utility.
  • Exploring the usage of utility classes for different API responses.

34:20 📊 Preparing to read data from an Excel sheet

  • Preparing to read data from an Excel sheet for data-driven testing.
  • Discussing the structure of Excel sheets and test data.

41:06 📄 Setting up dependencies for Apache POI API

  • Adding Apache POI API dependencies to interact with Excel files.
  • Ensuring the required libraries are included in the project.

46:35 📑 Explanation of reading data from an Excel sheet.

  • Creating a 2D object array to store Excel data.
  • Initializing the array with the correct dimensions.
  • Using nested loops to fill the array with data from the Excel sheet.

59:55 🧩 Integrating data from Excel into test cases.

  • Using the data from the Excel sheet as input to test cases.
  • Demonstrating how to access the Excel data in the test methods.
  • Highlighting the advantages of maintaining data directly in the test code instead of external resources.

01:10:44 🧰 Running Maven Commands

  • Running test cases from the command line using Maven.
  • Explanation of Maven’s clean install command.
  • Overview of the Maven build lifecycle and its stages.

01:13:05 🏗️ Maven and TestNG Integration

  • How Maven interacts with TestNG in test execution.
  • The role of the pom.xml file in running test cases.
  • Explanation of how Maven handles dependencies and test compilation.

01:16:36 📦 Building JAR Files in Maven

  • Discussion about creating JAR files with Maven.
  • Differentiating between normal JAR files and fat JAR files.
  • The importance of the folder structure in Maven projects.

01:33:53 🔍 Understanding Java Generics

  • The purpose of using generics in Java is to create flexible methods and classes that can work with different data types.
  • Generics allow you to specify a type parameter (T) that can represent any data type, making your code more reusable and type-safe.

01:35:45 📦 Advantages of Using Generics

  • Using generics improves performance as it eliminates unnecessary type casting by specifying the data type during compilation.
  • It enhances code readability and reusability by making it clear which data types are expected and returned by methods.
  • Generics help prevent runtime errors by providing compile-time type checking.

01:37:23 🏗 Creating Methods with Different Return Types

  • In scenarios where methods need to return different data types, generics allow you to use a single method with a type parameter (T) to handle various return types.
  • This approach avoids the need to create multiple methods for each data type, improving code maintainability.

01:39:02 💡 Converting Data from External Sources

  • When working with external sources like Excel, it’s essential to convert the data into equivalent Java data types to ensure compatibility and proper processing.
  • For instance, numeric data from Excel should be converted to Java integers or doubles for mathematical operations.

01:40:42 🛠 Using Object Mapper for Deserialization

  • While serialization is essential for sending data, deserialization is required to convert received data into usable Java objects.
  • Object Mapper is a useful tool for deserialization, converting JSON data into Java objects, facilitating data processing.

01:44:23 🔒 Handling HTTP Status Codes

  • Checking the HTTP response status code (e.g., 200 for success) is crucial for verifying the outcome of REST API calls.
  • Proper handling of status codes is necessary to determine the success or failure of API requests.

01:51:20 💬 Debugging Maven Project Issues

  • Occasionally, Maven projects may display debugging or parsing errors, but these often don’t affect the program’s functionality.
  • Refreshing and updating the Maven project can resolve some of these issues, ensuring smooth project execution.

29 RA FW 05 Multi Env Setup WithConfig Schema Validation Test TestNG Reports GIT Setup Repo Add Comm

00:01 🛠️ Framework Design: Adding Environment-specific Configuration Files

  • When dealing with different environments like QA, Dev, and Stage, you can create environment-specific configuration files.

05:14 📜 Supplying Environment Information via Maven

  • You can supply the environment information via Maven command line arguments using the -D flag, allowing you to specify which environment to use.

16:58 🔧 Integrating Environment-specific Configurations in Tests

  • Your test cases can seamlessly use the environment-specific configurations for endpoints, tokens, and more based on the environment you specify with Maven.

22:57 🔄 Multi-Environment Configuration

  • Discussing multi-environment configuration for automation.
  • Exploring the use of switch case in the framework.

23:28 🔍 Json Path Validation and Method Chaining

  • Addressing the usage of Json path validation and improving it.
  • Demonstrating method chaining for checking status codes and headers.

26:28 📊 TestNG Reports and Configuration

  • Exploring TestNG reports, including index.html and emailable report.html.
  • Discussing how to configure test environment-specific base URIs in TestNG.

30:10 🧪 Handling Failure Test Cases

  • Handling and identifying failure test cases in TestNG.
  • Running only failed test cases for debugging and analysis.

34:08 🚫 Disabling Test Cases and Adding Descriptions

  • Demonstrating how to disable specific test cases using the “enabled” attribute.
  • Adding descriptions to test cases and controlling their execution.

These sections provide insights into multi-environment configuration, Json Path validation, TestNG reports, handling failure test cases, and managing test case execution.

30 RA FW 06 Jenkins Setup Job CICD PipeLine Parameterization Scheduling NGROK Proxy

00:01 🚀 Setting up GitHub and Initial Steps

  • Pushing code to the master branch on GitHub.
  • The role of Git in source code management.
  • Preparing for integration with Jenkins.

02:33 🛠️ Creating an Automation Job in Jenkins

  • Setting up Jenkins to create an automation job.
  • Integrating the job with the GitHub repository.
  • Configuring the Maven-based project in Jenkins.

03:56 ⏰ Scheduling and Parameterization

  • Scheduling job execution in Jenkins.
  • Parameterizing build jobs.
  • Using NGROK proxy for job triggering.

04:52 🌐 Webhooks and Integration

  • Understanding webhooks in GitHub.
  • How webhooks bridge GitHub and Jenkins.
  • Automating job triggering through webhooks.

05:47 📊 Test Reporting and Analysis

  • Generating test reports in Jenkins.
  • Integrating Extent and TestNG reports.
  • Monitoring test case pass/fail results.

22:35 🔍 Setting up Jenkins for API Automation

  • Explanation of running API automation tests using Jenkins.
  • Discusses the execution environment and the role of Jenkins in triggering test runs.
  • Emphasizes that API automation doesn’t require a separate environment.

26:24 🔗 Triggering Jenkins Job after Code Changes

  • Demonstrates how to trigger a Jenkins job after code changes.
  • Shows how to commit and push code changes to the master branch.
  • Explains how Jenkins fetches code changes from Git.

38:52 🔄 Automating Test Execution with ngrok

  • Introduces automating test execution in Jenkins using ngrok.
  • Explains how to set up and authenticate ngrok.
  • Demonstrates connecting Jenkins to a specific port using ngrok for automatic test triggering.

45:25 🚀 Setting up Webhooks and NGROK Proxy for CI/CD

  • Establishing connections between NGROK proxy, GitHub Webhook, and Jenkins,
  • Configuring a webhook for a GitHub repository to trigger Jenkins jobs when code changes are pushed.

48:52 🔄 Configuring Jenkins Job for Webhook Trigger

  • Enabling GitHub webhook trigger for Jenkins job,
  • Configuring the job to run automatically when the webhook sends an event.

50:03 🏁 Testing the Setup and Webhook Trigger

  • Pushing code changes to GitHub to trigger the Jenkins job,
  • Verifying that the webhook-triggered job starts automatically.

56:00 📊 Parameterizing Builds with Choice Parameters

  • Adding a choice parameter to a Jenkins job to specify the environment,
  • Passing the selected environment to the Maven build command.

01:03:40 🔄 Understanding CI/CD Pipelines and Jobs

  • Explaining the concept of CI/CD pipelines and their stages,
  • Describing the need for both Jenkins jobs and pipelines in different projects.

01:10:08 🚀 Understanding Jenkins and Declarative Pipeline Syntax

  • Introduction to Jenkins and its role in creating pipelines.
  • Explanation of Declarative Pipeline Syntax, a key concept for building pipelines.

01:10:52 🔑 Best Practices for Jenkins File Location

  • Discusses where to store the Jenkins file within a project.
  • Emphasizes the importance of having the Jenkins file in the development repository for integration with pipeline stages.

01:12:30 🏗️ Creating a Dummy Dev Project

  • Explains the need to create a dummy development project for practice.
  • Describes setting up unit test cases within the dummy project.

01:13:24 🧩 Jenkins File Creation

  • Guides on creating a Jenkins file within an Eclipse project.
  • Highlights the use of Declarative Pipeline Syntax for Jenkins file.

01:14:36 ⚙️ Understanding Stages in Jenkins Pipeline

  • Explains the concept of stages in a Jenkins pipeline.
  • Describes the stages involved in a sample Jenkins pipeline, such as build, test, and deployment.

01:25:36 🔄 Creating a Jenkins Pipeline

  • Step-by-step guide on creating a Jenkins pipeline.
  • Configuring the pipeline script from source code management (SCM).

01:29:00 🛠️ Running a Jenkins Pipeline

  • Demonstrates the execution of a Jenkins pipeline.
  • Shows how pipeline stages progress and where to view detailed logs.

01:32:48 🔄 Modifying Jenkins Pipelines

  • Discusses how to modify and configure a Jenkins pipeline.
  • Explains the process for making changes to pipeline stages.

01:34:26 📝 Understanding Jenkinsfile syntax and its importance in DevOps,

  • Jenkinsfile syntax and its relevance in DevOps.
  • Explaining the basic format and stages of a Jenkinsfile.
  • The distinction between CI and CD in a DevOps pipeline.

01:36:01 🏭 Differentiating Continuous Integration (CI) and Continuous Deployment (CD) in DevOps,

  • Clarifying the concepts of Continuous Integration (CI) and Continuous Deployment (CD).
  • Highlighting the key distinctions between CI and CD in a DevOps pipeline.
  • Emphasizing the role of stakeholders in CI and CD processes.

01:40:12 🔄 Exploring the Shift Left and Shift Right testing approaches in DevOps,

  • Defining the concepts of Shift Left and Shift Right testing in a DevOps pipeline.
  • Explaining how Shift Left focuses on testing earlier in the development cycle.
  • Discussing scenarios where Shift Right testing is applied in a DevOps process.

01:45:36 🧰 Examining the tools used in a typical DevOps CI/CD pipeline,

  • Listing various tools used in a DevOps CI/CD pipeline, including Git, Jenkins, and more.
  • Providing an overview of the tools and their roles in the DevOps process.
  • Demonstrating how these tools contribute to automation and efficiency in software development.

01:56:27 🛠 Troubleshooting environment configuration for Maven and TestNG tests,

  • Addressing a specific issue related to environment configuration for Maven and TestNG tests.
  • Resolving an error in the XML configuration file (regression.xml).
  • Explaining the correct format for specifying the test class to be executed.

01:58:53 📄 Debugging a TestNG test suite configuration issue,

  • Debugging an issue related to TestNG test suite configuration.
  • Identifying the incorrect reference to a JSON file in the XML configuration.
  • Guiding on the correct way to specify the test class and package name for execution.

31 RA FW 07 Docker Setup Docker Image Integration With Jenkins PipeLine DockerContainer

32 RA FW 08 Maven Life Cycle Nexus Deployment FATJAR GitHub Actions

00:01 📚 Explanation of the importance of a common automation framework in API testing,

  • Common automation framework simplifies API automation and promotes reusability.
  • Avoids duplication of efforts by sharing the framework with other teams in the organization.

01:11 📦 Introduction to “fat jar” in Java,

  • A “fat jar” is a bundled collection of Java classes, including external libraries, used for distribution.
  • It simplifies sharing projects with external dependencies without needing to add each library separately.

04:11 🧩 Understanding the structure of a common automation framework,

  • SRC main Java for custom code and utilities.
  • SRC test Java for writing test cases using the framework.
  • Utilizing external third-party libraries to enhance functionality.

08:09 🔀 Challenges with multiple teams using different tools and technologies for automation,

  • High turnover of team members can lead to difficulties in maintaining different tools.
  • Team members often prefer tools they are comfortable with, leading to conflicts.
  • A centralized approach to automation promotes consistency and efficiency.

15:11 🚀 The role of Maven in creating and deploying jars,

  • Maven is used to create both normal and “fat jars” in Java.
  • Deployment of the jars is done using a deployment Maven plugin.
  • Jars are deployed to a centralized repository, such as Nexus, for easy access.

18:44 👨‍💻 Benefits of using a common automation framework for multiple teams,

  • Teams can focus on writing test cases and utilizing the common framework.
  • Facilitates easy sharing of the framework and updates across different projects.
  • Standardizes tools, technologies, and libraries, enhancing collaboration and resource flexibility.

22:00 🧩 Advantages of a common automation framework:

  • Increases productivity by ensuring a consistent code structure.
  • Facilitates collaboration among team members.
  • Ensures a standardized approach to automation.

22:57 📉 Drawback of a core automation team:

  • Limited domain knowledge.
  • Less opportunity for automation development.
  • Highly dependent on the core automation framework.

25:30 📦 Designing multiple automation frameworks:

  • Creating separate frameworks for API, UI, and mobile testing.
  • Deploying different fat JARs for each framework.
  • Tailoring frameworks to the specific technology used.

32:14 🛠️ Using Maven for building JARs:

  • Explains the Maven lifecycle phases (compile, test, package, etc.).
  • Demonstrates creating a fat JAR with dependencies using Maven assembly plugin.
  • Highlights the importance of artifact management with Nexus.

41:17 🐋 Running Nexus with Docker:

  • Shows how to run Nexus as a Docker container.
  • Accessing Nexus on port 8081 after container creation.

These sections provide insights into the advantages and drawbacks of a common automation framework, the design of multiple automation frameworks, building JARs with Maven, and running Nexus with Docker for artifact management.

45:08 🚀 Deploying Nexus Using Docker

  • Deploying Nexus using Docker and accessing it.
  • Obtaining the Nexus admin password from within a Docker container.

48:20 🔒 Changing Nexus Admin Password and Setting Up Repository

  • Changing the Nexus admin password.
  • Setting up a repository in Nexus for deployment.

54:03 📦 Using Deployed JAR in a Separate Project

  • Creating a new Maven project for a User Management API framework.
  • Adding dependencies from the deployed Nexus JAR.
  • Demonstrating the use of dependencies from the core framework in a separate project.

01:03:05 🧰 Understanding the Maven Lifecycle Phases

  • Discussing the different phases of the Maven lifecycle, including compilation, testing, packaging, and deployment.
  • Highlighting the plugins associated with each phase.

01:08:07 🤖 Introduction to GitHub Actions

  • Introduction to GitHub Actions as a CI/CD tool provided by GitHub.
  • Mentioning the creation of YAML-based workflows for automation.

01:10:01 📄 Using YAML for GitHub Actions Workflows

  • Explaining the use of YAML files in GitHub Actions workflows, similar to Jenkinsfiles.
  • Highlighting the concept of creating CI/CD workflows for code commits and pushes.

These sections cover various aspects of deploying Nexus, changing the admin password, using the deployed JAR in a separate project, understanding the Maven lifecycle phases, and introducing GitHub Actions as a CI/CD tool.

01:10:16 🛠️ Setting up GitHub Actions for CI/CD

  • GitHub Actions simplifies CI/CD solutions.
  • Create a YAML file with different stages.
  • GitHub Actions execute these stages, making it a CI/CD solution.

01:12:30 🌐 Exploring GitHub Actions Workflows

  • GitHub Actions offers various workflow suggestions for different tools and technologies.
  • You can create custom workflows based on your project’s needs.
  • Public repositories are required to utilize GitHub Actions.

01:13:41 ⚙️ Configuring a Maven Workflow in GitHub Actions

  • Create a .github/workflows folder and a maven.yaml file in your repository.
  • Define the workflow with jobs and commands in the YAML file.
  • GitHub Actions run on Linux machines on GitHub’s cloud.

01:16:00 🧪 Running Tests and Building in GitHub Actions

  • GitHub Actions build and run tests on an Ubuntu machine in the cloud.
  • It’s suitable for running automated tests and generating responses.
  • GitHub Actions is a headless environment, not ideal for UI tests.

01:18:13 🚀 GitHub Actions for Quick Test Checks

  • GitHub Actions are straightforward for quick test case checks and build status monitoring.
  • It’s not as feature-rich as Jenkins but serves its purpose.
  • GitHub Actions is advantageous for API automation tests.

33 GraphQL Intro API Examples Automation With RestAssured

00:00 🚀 Introduction to GraphQL

  • GraphQL is a language, API, and server-side runtime for data queries.
  • Developed by Facebook, open-source since 2015.
  • Four major concepts: Schema, Query, Mutation, and Subscription.

03:17 📊 Advantages of GraphQL

  • Flexible queries: Clients can request exactly the data they need.
  • Reduced over-fetching and under-fetching of data.
  • Single request for all required data, reducing the number of requests.

05:05 📡 Real-time Data with GraphQL

  • Subscription model for real-time communication between clients and servers.
  • Clients can subscribe to specific events and receive updates.
  • Ideal for live feed data, chat applications, and real-time notifications.

16:38 ⚙️ Query, Mutation, and Subscription

  • Query for fetching data, like a GET request.
  • Mutation for creating, updating, or deleting data.
  • Subscription enables real-time data updates between client and server.

21:49 🔄 Rest vs. GraphQL Data Fetching

  • Rest has fixed data structure in endpoints.
  • GraphQL allows flexible queries tailored to specific data needs.
  • Rest often requires multiple requests for different data, while GraphQL uses a single request.

22:30 🚀 GraphQL offers superior performance compared to REST API by allowing field selection in queries, eliminating over-fetching and under-fetching issues.

  • GraphQL allows clients to specify the exact fields they need in a query, reducing unnecessary data transfer.
  • REST APIs often suffer from over-fetching and under-fetching problems, resulting in inefficient data transfer.

23:55 🌐 GraphQL simplifies endpoint management by offering a single endpoint and avoiding versioning for backward compatibility.

  • GraphQL typically uses a single endpoint, making it easier to manage and eliminating the need for versioning.
  • In contrast, REST APIs may require multiple endpoints for different resources, leading to complexity.

25:05 📡 REST APIs excel in caching, making them suitable for efficient browser caching and complex caching strategies.

  • REST APIs allow for effective caching, reducing the need for repeated server calls.
  • GraphQL, due to its dynamic nature, doesn’t support caching in the same way, as data requirements may vary.

26:29 📊 GraphQL provides fixed response structures per endpoint, ensuring a consistent schema, while REST APIs offer dynamic responses.

  • GraphQL responses have a fixed structure, defined by the schema, which ensures consistency.
  • REST API responses can vary based on the endpoint and data requirements in each request.

27:53 📜 Mutations in GraphQL are used to create, update, or delete data, and they define the data parameters and structure for the request and response.

  • Mutations in GraphQL are operations used to create, update, or delete data.
  • They specify input parameters and the structure of the response data.
  • Mutations allow clients to tailor their requests for specific data operations.

30:42 🔄 Subscriptions in GraphQL enable real-time updates and are valuable for features like live feeds and chat applications.

  • GraphQL subscriptions facilitate real-time updates whenever specific events occur on the server.
  • They are useful for implementing live feeds, real-time notifications, and chat applications.
  • Subscriptions enable clients to receive real-time data without continuous polling of the server.

34 WireMock API Mocking GET POST DELETE STUBs

00:00 🤖 Introduction to Mocking APIs and Service Virtualization

  • Mocking APIs and service virtualization are essential concepts for testing and development.
  • Understanding what mocks are and when to use them.

02:18 🧐 The Need for Mocking APIs

  • Exploring scenarios where mocking APIs become crucial.
  • Testing when the actual backend is not ready and creating a mock server for testing.

05:05 📈 Using WireMock and Mockito for Mocking

  • Introduction to tools like WireMock and Mockito for creating mock servers.
  • How these tools facilitate the creation of mock APIs for testing.

10:28 🤔 Mocking for Hardware and IoT Testing

  • How mocking APIs can be used for hardware and IoT testing.
  • Simulating device behavior and interactions with mock servers.

15:18 💼 Mocking for Integration Testing in Large Projects

  • Using mock APIs for integration testing within large projects and teams.
  • Creating mock stubs to test components that are not yet ready for integration.

20:55 🛠️ Setting Up WireMock Server and Mocking a GET API

  • Creating a WireMock server on localhost and port 8085.
  • Defining a behavior for a GET API call to return a dummy user in JSON format.

42:04 🧪 Testing the Mocked GET API with WireMock and RestAssured

  • Setting up a test method with @BeforeTest and @AfterTest annotations to start and stop the WireMock server.
  • Using RestAssured to call the mocked GET API and validate the response.

44:45 🚀 Creating a Mock API for GET Requests

  • Demonstrated how to create a mock API for GET requests using WireMock.
  • Showed how to define a mock endpoint and its response behavior, including status codes and response bodies.

56:23 🛠️ Testing a GET Request with Query Parameters

  • Explored testing a GET request with query parameters in a mock API.
  • Demonstrated setting up a WireMock server to handle query parameters and verifying the expected response.

01:11:28 📝 Creating a Mock API for POST Requests

  • Covered how to create a mock API for POST requests using WireMock.
  • Discussed defining the endpoint, specifying headers, and preparing for testing POST requests.
  • Please note that the issue with the GET request with query parameters was not resolved in the provided transcript chunk. The POST request setup was introduced for further exploration.

01:13:07 📝 Explains how to define a WireMock API for mocking a POST call.

  • When defining a WireMock API for a POST call, specify the content type as “application/json.”
  • Define the request body as a JSON object, such as {“name”: “Naveen”}, which will be sent when the API is called.
  • Set the expected response status code to 201 (Created) and include a response header with content type “application/json” and a response body with the message “user is created.”

01:26:22 📝 Demonstrates creating a Java test for the WireMock API.

  • To test the WireMock API, create a Java test class (e.g., “CreateUserAPITest”).
  • Start the WireMock server before the test and stop it afterward using the same code for server setup and teardown.
  • Write a test method (e.g., “createDummyUserTest”) using JUnit’s “@Test” annotation to make the API call and perform assertions.

01:29:37 📝 Discusses best practices for using WireMock to create API mocks.

  • Never include assertions or test cases within WireMock mocks. They are intended to define behavior, not perform testing.
  • Mocks should be static and not dynamic, representing fixed, predefined responses.
  • WireMock is useful for creating dummy data to simulate various scenarios, allowing UI developers to test their integration with these dummy APIs.

35 Docker NewMan Postman Images Java11 HTTP Client GET POST Serialization DeSerialization

00:00 🐳 Creating Docker images for API frameworks and Postman Collections

  • Discussing the concept of creating Docker images for API frameworks and Postman Collections.
  • Highlighting the benefit of Docker for distributing and running test cases.
  • Exploring the idea of creating a Docker image for Postman Collections and Newman.

04:25 📦 Creating a Dockerfile for Newman and Postman Collections

  • Explaining the Dockerfile creation for Newman and Postman Collections.
  • Specifying the need for Node.js and npm for Newman.
  • Describing the steps to install Newman and generate HTML reports.
  • Demonstrating the setup for copying collection and environment JSON files into the container.

08:13 📊 Running Test Cases and Generating Reports in Docker Container

  • Demonstrating how to run test cases in a Docker container.
  • Explaining the need for volume mapping to fetch generated reports.
  • Discussing the usage of Docker volumes to transfer reports from the container to the local machine.
  • Displaying the generated Newman HTML report in the local environment.

00:00 📋 Introduction to using Docker for creating and sharing images.

  • Docker allows for creating and sharing container images.
  • Images can be easily distributed without the need for installations.

05:36 🐳 Creating a Docker image for running Postman Newman tests.

  • The process of creating a Docker image for Postman Newman.
  • How to use Docker to package and distribute test environments.

10:54 🚀 Running Postman Newman tests in a Docker container.

  • Demonstrating how to run Postman Newman tests in a Docker container.
  • Benefits of using Docker for test automation and distribution.

20:14 💻 Pushing a Docker image to Docker Hub for sharing.

  • Explaining how to push a Docker image to Docker Hub for sharing.
  • Making Docker images accessible to others for testing.

30:45 🏭 Utilizing Docker images for test automation and distribution.

  • Highlighting the advantages of using Docker images for test automation and distribution.
  • Sharing Docker images with team members and clients for easy test execution.

49:59 📝 Handling exceptions and multiple catch blocks in HTTP client code.

  • Adding catch blocks for IOException and InterruptedException.

50:13 🤖 HTTP response in Java HTTP client.

  • Storing HTTP response with generics of a string.
  • Using the send method to retrieve the HTTP response.

51:04 💡 Working with HTTP response in Java.

  • Accessing the status code of the HTTP response.
  • Extracting and displaying the response body.

52:34 🧐 Challenges of using JSONPath and deserialization in HTTP client.

  • Discussion of limitations when using JSONPath with HTTP client.
  • Exploring deserialization and converting JSON to POJO (Plain Old Java Object).

54:12 🚀 Creating a POST request with Java HTTP client.

  • Creating a POST request for user creation.
  • Serializing JSON data and sending the POST request.

55:22 📋 Handling JSON serialization and deserialization in Java.

  • Creating a POJO class for user data.
  • Using Jackson API for JSON serialization and deserialization.

01:10:31 🎯 Successful POST request with JSON serialization.

  • Demonstrating the successful creation of a user with JSON data.
  • Highlighting the benefits of using POJOs for request and response data.

01:13:29 🔄 JSON deserialization in Java HTTP client.

  • Deserializing JSON response into a Java object.
  • Displaying the deserialized user data from the response.

These sections provide a breakdown of the video content, including error handling, HTTP response handling, JSON serialization and deserialization, and working with POST requests in Java HTTP client.

01:14:40 🧐 Deserialization Error and Solution

  • Understanding deserialization error.
  • Solving the issue by adding an ID field to the class.

01:19:47 📄 Implementing toString Method

  • Overriding the toString method in the class.
  • Displaying a user object’s string representation.

01:24:36 📥 Making a GET Request

  • Constructing an HTTP GET request with a dynamic user ID.
  • Checking the response status and body.

01:29:52 🧩 Comparison of Selenium and JDK 11 HTTP Client

  • Discussing the use of JDK 11 HTTP Client in Selenium.
  • Addressing the integration of new features and future development.

Avatar for Softwaretestingo Editorial Board

I love open-source technologies and am very passionate about software development. I like to share my knowledge with others, especially on technology that's why I have given all the examples as simple as possible to understand for beginners. All the code posted on my blog is developed, compiled, and tested in my development environment. If you find any mistakes or bugs, Please drop an email to softwaretestingo.com@gmail.com, or You can join me on Linkedin.

Leave a Comment