API Testing Interview Questions and Answers for SDET, QA and Manual Testers

Here are my API Testing Questions and Answers for SDETs, QA and Manual Testers. Read the interview questions on API Testing fundamentals, what to test in API Testing, writing effective API Test Cases, API Testing types, API Testing tools and Examples of API Test Cases.

If you want my complete set of API Testing Interview Questions and Answers as a document that additionally contain the following topics, you can message me on my LinkedIn profile or send me a message in the Contact Us form in the right pane:
API Testing with Postman, API Testing with SoapUI, API Testing with REST Assured, API Testing challenges and solutions, API Testing error codes, advanced API Testing techniques, and Interview Preparation Questions and Answers, with tips.

Question: What’s API testing, and why is it important?
Answer: API testing means testing Application Programming Interfaces (APIs) to test if they work as expected, meet performance standards, and handle errors. APIs handle the communication between software systems, enabling them to exchange data and functionality. API testing is important for the following reasons: 
- Logic Validation: APIs can encapsulate the core business logic of an application. API testing finds out if that logic works as intended. 
- Cascading Effect Prevention: Since APIs often connect multiple systems, a failure in one API can disrupt the entire system. For example, in an e-commerce system, if the API managing payment processing fails, it can prevent order confirmations and impact inventory updates, customer notifications, and financial records. 
- Integration Validation: APIs handle the interactions between different systems. Testing these interactions for correctness, reliability, performance and security is critical. 
- Early Bug Detection: By testing APIs before the UI is complete, defects can be identified earlier, reducing downstream issues.

Question: What’s the primary focus of API testing?
Answer: The primary focus areas include: 
- Functionality: Testing if the API executes intended operations and returns accurate responses. Example: A "getUserDetails" API should return the correct user details based on the provided user ID. 
- Performance: Validating the API’s speed and responsiveness under varying loads. Example: Testing if the API responds within 300 ms when handling 100 simultaneous requests. 
- Security: Checking data protection, authentication, and authorization mechanisms. Example: Ensuring unauthorized users cannot access restricted endpoints. 
- Reliability: Confirming if the API delivers consistent results across multiple calls and scenarios. Example: A weather API should always return the correct temperature for a given city. 

Question: Is API testing considered functional or non-functional testing type?
Answer: API testing is often regarded as functional but also includes non-functional tests (performance, security, etc.). The objective of API testing is to validate if the API performs its expected functions accurately. API testing also involves non-functional testing types, depending on the test scope: 
- Performance Testing: To measure the API’s responsiveness and stability under different conditions. Example: Load testing an API that handles ticket booking during a flash sale. 
- Security Testing: To validate data confidentiality and access control mechanisms. Example: Testing an API for vulnerabilities like SQL injection or unauthorized access.

Question: How does API testing differ from UI testing?
Answer: API testing focuses on the backend logic, while UI testing validates the user interface. Their differences include:
API Testing vs UI Testing
- Scope: Validates backend systems and business logic vs Tests user interface interactions.
- Speed: Faster since it bypasses the graphical interface vs Slower due to rendering processes;
- Reliability: API tests are more stable; less prone to flaky results caused by UI changes vs Prone to instability if UI elements change.
Example: API example - Verifying a "createOrder" API works correctly. UI example - Testing if the "Place Order" button functions properly.

Question: Does API testing come under integration testing or system testing test levels?
Answer: API testing is considered a part of integration testing because it validates how different components or systems interact with each other.
Example: Testing an API that bridges a payment gateway with an e-commerce platform: The focus would be on testing the correct and complete communication, accurate data exchange, and correct handling of alternate workflows like declined payments.

Question: Can API testing also fall under system testing test level?
Answer: Yes, API testing can be a part of system testing when it is used to validate end-to-end workflows that involve APIs.
Example: An order management system involves several APIs for inventory, payment, and customer notification. System testing would involve validating the entire order placement process, including all the APIs in the workflow.

Question: Why is classifying API testing important?
Answer: Classifying API testing determines the test scope and test approach for testing.
Answer: For example: 
- For integration testing, focus on inter-component communication. 
- For system testing, test the APIs as part of larger workflows to ensure end-to-end functionality.

Question: What are the key concepts in API testing that you know as an SDET, QA or manual tester?
Answer: API testing has the following key concepts: 
- Endpoints: Endpoints are the URLs where APIs are accessed.
Example: A weather API endpoint might look like https://api.weather.com/v1/city/temperature. Tip: You should always document endpoints clearly, including required parameters and response formats.
- Requests and Methods: APIs use HTTP methods to perform operations. The common ones are: 
1. GET: Retrieve data. Example: Fetching user details with GET /user/{id}. 
2. POST: Create new data. Example: Creating a new user with POST /user. 
3. PUT: Update existing data. Note: that PUT may also be used to create-or-replace resources depending on API design. Example: Updating user details with PUT /user/{id}. 
4. DELETE: Remove data. Example: Deleting a user with DELETE /user/{id}. Tip: Verify that the API strictly adheres to the HTTP method conventions.

Request Payloads and Parameters
APIs often require input parameters or payloads to function correctly: 
1. Query Parameters: Added to the URL (e.g., ?userId=123). 
2. Body Parameters: Sent in the request body (e.g., JSON payload for POST requests). 
Tip: Validate edge cases for parameters, such as missing, invalid, or boundary values.

Responses and Status Codes
API responses include data and status codes. Design tests for all possible response scenarios, including success, error, and unexpected responses. Common status codes are: 
1. 200 OK: Successful request. 
2. 201 Created: Resource successfully created. 
3. 204 No Content
4. 400 Bad Request: Client-side error. 
5. 401 Unauthorized: Missing or invalid authentication. 
6. 403 Forbidden
7. 404 Not Found
8. 429 Too Many Requests
9. 500 Internal Server Error: API failure.

Headers and Assertions
Headers carry metadata such as authentication tokens, content type, and caching information. Example: Authorization: Bearer <token> for authenticated APIs. Tip: Always validate headers for correctness and completeness. 

Assertions validate the API's behavior by checking: 
1. Response Status Codes: Validate if the expected codes are returned. 
2. Response Body: Validate if the response data matches the expected format and content. 
3. Performance: Measure if the API responds within acceptable time limits. 
Tip: Use libraries like REST Assured or Postman to implement assertions quickly.

Question: Why is API testing important in modern software development?
Answer: Modern software relies heavily on APIs for communication, making their reliability paramount: 
- APIs Drive Application Functionality: APIs implement the key features of applications, like user authentication, data retrieval, and payment processing. Example: A banking app’s core functionalities, such as checking account balances, transferring funds, and viewing transaction history, are implemented with APIs. 
- Integration Testing: APIs connect multiple systems. Ensuring their proper integration prevents cascading failures. Example: In a ride-sharing app, APIs for user location, driver availability, and payment must work together correctly. 
- Early Testing Opportunity: APIs can be tested as soon as they are developed, even before the UI is ready. Example: Testing an e-commerce app’s POST /addToCart API before the cart UI is finalized. 
- Microservices Architecture: Applications are composed of multiple independent services connected via APIs. Example: A video streaming platform might use separate APIs for authentication, video delivery, and recommendation engines. 
- Scalability and Performance Assurance: APIs must be able to handle high traffic and large datasets efficiently. Example: During a Black Friday sale, an e-commerce platform’s APIs must manage thousands of concurrent users adding items to their carts. 
- Cost Efficiency: API issues identified early are cheaper to fix than UI-related defects discovered later. 

Tips and Tricks for Testers: 
- Use Mock Servers: Mock APIs allow you to test scenarios without using the ready APIs. 
- Validate Negative Scenarios: Don’t just test happy paths; additionally test invalid inputs, unauthorized access, and server downtime. 
- Automate Tests: Automating repetitive API tests saves time for test coverage. Tools like REST Assured and Postman can help you automate validations for different test scenarios.
Note: You can follow me in LinkedIn for more practical information in Test Automation and Software Testing at the link, https://www.linkedin.com/in/inderpsingh

Question: How do you conduct functional testing of APIs?
Answer: Functional testing tests if the API performs its intended operations accurately and consistently. It includes the following tests: 
- Endpoint Validation: Validate if the API endpoints respond to requests as expected. Example: Testing if the GET /user/{id} endpoint retrieves the correct user details for a given ID. 
- Input Validation: Test how the API handles various input scenarios: o Valid inputs. o Invalid inputs (e.g., incorrect data types or missing required fields). o Boundary values (e.g., maximum or minimum allowable input sizes). Example: Testing an API that accepts a date range to ensure it rejects malformed dates like 32-13-2025. 
- Business Logic Testing: Validate that the API implements the defined business rules correctly and completely. Example: For an e-commerce API, ensure the POST /applyCoupon endpoint allows discounts only on eligible products. 
- Dependency Validation: Test how APIs interact with other services. Example: If an API triggers a payment gateway, test if the API handles responses like success, failure, and timeout correctly.
Tip: Use tools like Postman to design and execute functional test cases effectively. Automate repetitive tests with libraries like REST Assured for scalability.

Question: What do you validate in API responses?
Answer: Validating API responses involves validating the accuracy, structure, and completeness of the data returned by the API. 
- Status Codes: Confirm that the correct HTTP status codes are returned for each scenario. o 200 OK: For successful requests. o 404 Not Found: When the requested resource does not exist. o 500 Internal Server Error: For server-side failures. 
- Response Body: Validate the structure and data types. Example: If the API returns user details, validate if the response contains fields like name, email, and age with the correct types (e.g., string, string, and integer). 
- Schema Validation: Check if the API response matches the expected schema. Tip: Use schema validation tools like JSON Schema Validator to automate this process. 
- Data Accuracy: Test if the API returns correct and expected data. Example: Testing the GET /product/{id} endpoint to verify that the price field matches the database record for the product. 
- Error Messages: Validate that error responses are descriptive, consistent, and secure. Example: If a required parameter is missing, the API should return a clear error like "Error: Missing parameter 'email'".
Tip: Include assertions for all fields in the response to avoid missed validations during regression testing.

Question: How do you perform security testing for APIs?
Answer: Security testing focuses on protecting APIs from unauthorized access, data breaches, and malicious attacks. Key test scenarios include: 
- Authentication and Authorization: Test if the API enforces authentication (e.g., OAuth, API keys). Verify role-based access control (RBAC). Example: A DELETE /user/{id} endpoint should only be accessible to administrators. 
- Input Sanitization: Check for vulnerabilities like SQL injection or cross-site scripting (XSS). Example: Test input fields by submitting malicious payloads like '; DROP TABLE [Table];-- to confirm if they are sanitized. Safety Note: Never run destructive payloads against production systems. Do not run destructive payloads against any real database; example is for illustration only. Use safe test beds or intentionally vulnerable labs.
- Data Encryption: Test that sensitive data is encrypted during transmission (e.g., via HTTPS). Example: Check if login credentials sent in a POST /login request are transmitted securely over HTTPS. 
- Rate Limiting: Validate that the API enforces rate limits to prevent abuse. Example: A public API should reject excessive requests from the same IP with a 429 Too Many Requests response. 
- Token Expiry and Revocation: Test how the API handles expired or revoked authentication tokens. Example: Test that a revoked token results in a 401 Unauthorized response.
Tip: Use tools like OWASP ZAP and Burp Suite to perform comprehensive API security testing.

Question: What aspects of API performance do you test?
Answer: API performance testing evaluates the speed, scalability, and reliability of APIs under various conditions. 
- Response Time: Measure how quickly the API responds to requests. Example: For a weather API, test if the response time for GET /currentWeather is under 200ms. 
- Load Testing: Test the API's behavior under normal and peak load conditions. Example: Simulate 100 concurrent users hitting the POST /login endpoint to verify stability. 
- Stress Testing: Determine the API's breaking point by testing it under extreme conditions. Example: Gradually increase the number of requests to an API until it fails to identify its maximum capacity. 
- Spike Testing: Validate the API’s ability to handle sudden traffic surges. Example: Simulate a flash sale scenario for an e-commerce API. 
- Resource Usage: Monitor server resource usage (CPU, memory) during API tests. Example: Confirm that the API doesn’t consume excessive memory during a batch operation like POST /uploadBulkData. 
- Caching Mechanisms: Test if the API effectively uses caching to improve response times. Example: Validate if frequently requested resources like product images are served from the cache.
Tip: Use tools like JMeter and Gatling for automated performance testing. Monitor metrics like latency, throughput, and error rates to identify bottlenecks.
Note: In order to expand your professional network and share opportunities with each other, you’re welcome to connect with me (Inder P Singh) in LinkedIn at https://www.linkedin.com/in/inderpsingh

Question: What best practices for writing API test cases do you follow?
Answer: Writing effective API test cases needs a methodical approach. Here are some best practices: 
- Understand the API Specification: Study the API documentation, including endpoint definitions, request/response formats, and authentication mechanisms. Example: For a GET /user/{id} API, understand its parameters (id), response structure, and expected error codes. 
- Identify Test Scenarios: Convert the API’s functionality into testable scenarios: o Positive test cases: Validate the expected behavior for valid inputs. o Negative test cases: Test if the API handles invalid inputs gracefully. o Edge cases: Test boundary values to identify vulnerabilities. Example: For a pagination API, test scenarios include valid page numbers, invalid page numbers (negative values), and boundary values (e.g., maximum allowed page). 
- Use a Modular Approach: Create reusable test scripts for common actions like authentication or header validation. Example: Write a reusable function to generate a valid authorization token for secure APIs. 
- Use Assertions: Verify key aspects like status codes, response time, response structure, and data accuracy. Example: Assert that the response time for GET /products is under 200ms. 
- Automate Wherever Possible: Use tools like REST Assured or Postman to automate test case execution for scalability and efficiency. Example: Automate regression tests for frequently changing APIs to minimize manual effort. 
- Prioritize test cases based on business impact and API complexity. High-priority features should have extensive test coverage.

Question: How do you define inputs and expected outputs for API test cases?
Answer: Inputs: 
- Define the parameters required by the API. 
o Mandatory Parameters: Verify that all required fields are provided. 
o Optional Parameters: Test the API behavior when optional parameters are included or excluded. 
- Test with various input types: o Valid inputs: Proper data types and formats. o Invalid inputs: Incorrect data types, missing fields, and null values.
Example: For a POST /createUser API, inputs may include:

{
  "name": "John Doe",
  "email": "john.doe@example.com",
  "age": 30
}

Expected Outputs: 
- Define the expected API responses for various scenarios: 
o Status Codes: Verify that the API returns correct HTTP status codes for each scenario (e.g., 200 for success, 400 for bad request). 
o Response Data: Specify the structure and values of the response body. o Headers: Verify essential headers like Content-Type and Authorization.
Example: For the POST /createUser API, the expected output for valid inputs might be:

{
  "id": 101,
  "message": "User created successfully."
}

Question: What’s a well-structured API test case template?
Answer: A structured template enables writing test cases that are complete, reusable, and easy to understand. 

Tip: Use tools like Jira, Excel, or test management software to document and track test cases systematically.

Question: What’s Functional Testing in API testing?
Answer: Functional Testing validates if the API meets its specified functionality and produces the correct output for given inputs. It tests if the API behaves as expected under normal and edge-case scenarios. 
Key Aspects to Test: 
- Validation of Endpoints: Test that each endpoint performs its intended functionality. Example: A GET /user/{id} API should fetch user details corresponding to the provided ID. 
- Input Parameters: Test required, optional, and invalid parameters. Example: For a POST /login API, validate behavior when required parameters like username or password are missing. 
- Response Validations: Verify the response codes, headers, and body. Example: Assert that Content-Type is application/json for API responses. 

Tips for API Functional Testing: 
- Use data-driven testing to validate multiple input combinations. 
- Automate functional tests with tools like REST Assured or Postman for efficiency.

Question: What’s API Load Testing?
Answer: Load Testing assesses the API’s performance under normal and high traffic to test if it handles expected user loads without degradation. 
Steps to Perform Load Testing: 
- Set the Benchmark: According to the API performance requirements, define the expected number of concurrent users or requests per second. Example: An e-commerce API might need to handle 500 concurrent product searches. 
- Simulate the Load: Use tools like JMeter or Locust to generate virtual users. Example: Simulate 200 users simultaneously accessing the GET /products endpoint. 
- Monitor Performance Metrics: Track response time, throughput, and server resource utilization. Example: Verify that response time stays below 1 second and CPU usage remains under 80%. 

Common Issues Identified: 
- Slow response times due to inefficient database queries. 
- Server crashes under high load. 

Tips for Load Testing: 
- Test with both expected and peak traffic to prepare for usage spikes. 
- Use realistic data to simulate production-like scenarios.

Question: Why is Security Testing important for APIs?
Answer: APIs can be targets for malicious attacks, so Security Testing tests if they are protected against vulnerabilities and unauthorized access. 
Important Security Tests: 
- Authentication and Authorization: Verify secure implementation of mechanisms like OAuth2 or API keys. Example: Ensure a user with user role cannot access admin-level resources. 
- Input Validation: Check for injection vulnerabilities like SQL injection or XML External Entity (XXE) attacks. Example: Test the API with malicious payloads such as "' OR 1=1--". 
- Encryption and Data Privacy: Validate that sensitive data is encrypted during transit using HTTPS. Example: Ensure Authorization headers are not logged or exposed. 
- Rate Limiting and Throttling: Test whether APIs restrict the number of requests to prevent abuse. Example: A GET /data endpoint should return a 429 Too Many Requests error after exceeding the request limit.
Tip: Use tools like OWASP ZAP and Burp Suite for vulnerability scanning.

Question: What’s Interoperability Testing in API testing?
Answer: Interoperability Testing tests if the API works correctly with other systems, platforms, and applications.
Steps to Perform Interoperability Testing:
- Validate Protocol Compatibility: Check API compatibility across HTTP/HTTPS, SOAP, or gRPC protocols. Example: Test that a REST API supports both JSON and XML response formats, if required. 
- Test Integration Scenarios: Test interactions between APIs and third-party services. Example: Verify that a payment API integrates correctly with a third-party gateway like Stripe. 
- Cross-Platform Testing: Test API accessibility across different operating systems, browsers, or devices. Example: Verify that the API has consistent behavior when accessed via Windows, Linux, or macOS. 

Common Issues: 
- Inconsistent response formats between systems. 
- Compatibility issues due to different versions of an API. 

Tips for Interoperability Testing: 
- Use mock servers to simulate third-party APIs during testing. 
- Validate response handling for various supported data formats (e.g., JSON, XML).

Question: What’s Contract Testing in API testing?
Answer: Contract Testing tests if the API adheres to agreed-upon specifications between providers (backend developers) and consumers (frontend developers or external systems). 
Steps to Perform Contract Testing: 
- Define the Contract: Use specifications like OpenAPI (Swagger) to document expected request/response structures. Example: A GET /users API contract may specify that id is an integer and name is a string. 
- Validate Provider Implementation: Verify the API provider adheres to the defined contract. Example: Verify that all fields in the contract are present in the actual API response. 
- Test Consumer Compatibility: Verify that consumers can successfully interact with the API as per the contract. Example: Check that a frontend application can parse and display data from the API correctly. 

Common Tools for Contract Testing: -
 PACT: A widely-used framework for consumer-driven contract testing. 
- Postman: For validating API responses against schema definitions. 

Tips for Contract Testing: 
- Treat contracts as living documents and update them for every API change. 
- Automate contract testing in CI/CD pipelines to detect issues early. 

In order to stay updated and view the latest tutorials, subscribe to my Software and Testing Training channel (341 tutorials) at https://youtube.com/@QA1

Question: What’s Postman, and why is it popular for API testing?
Answer: Postman is a powerful API testing tool that has a user-friendly interface for designing, executing, and automating API test cases. It’s widely used because it supports various API types (REST, SOAP, GraphQL) and enables both manual and automated testing. 
Features of Postman: 
- Collections and Requests: Organize test cases into collections for reusability. Example: Group all CRUD (meaning Create, Read, Update and Delete) operations (POST, GET, PUT, DELETE) for a user API in a collection. 
- Environment Management: Use variables to switch between different environments like development, staging, and production. Example: Define {{base\_url}} for different environments to avoid hardcoding endpoints. 
- Built-in Scripting: Use JavaScript for pre-request and test scripts to validate API responses. Example: Use assertions like pm.expect(response.status).to.eql(200);. 
- Automated Testing with Newman: Run collections programmatically in CI/CD pipelines using Newman, Postman’s CLI tool. 

Few Best Practices for Using Postman: 
- Use Version Control: Export and version collections in Git to track changes. 
- Use Data-Driven Testing: Use CSV/JSON files for parameterizing tests to cover multiple scenarios. Example: Test the POST /register API with various user data combinations. 
- Automate Documentation: Generate API documentation directly from Postman collections for seamless collaboration.

Question: What’s SoapUI, and how does it differ from Postman?
Answer: SoapUI is a comprehensive API testing tool designed for SOAP and REST APIs. Unlike Postman, which is more user-friendly, SoapUI provides advanced features for functional, security, and load testing, making it more suitable for complex enterprise-level APIs. 

Steps to Get Started with SoapUI: 
- Install SoapUI: Download and install the free version (SoapUI Open Source) or the licensed version (ReadyAPI) for advanced features. 
- Create a Project: Import API specifications like WSDL (for SOAP) or OpenAPI (for REST) to create a test project. Example: Load a WSDL file to test a SOAP-based payment processing API. 
- Define Test Steps: Create test cases with multiple steps such as sending requests, validating responses, and chaining steps. Example: For a login API, test POST /login and validate that the token from the response is used in subsequent API calls. 
- Use Assertions: Use built-in assertions for validating response status codes, time, and data. Example: Check if the <balance> field in a SOAP response equals $1000. 

Advanced Features: 
- Data-Driven Testing: Integrate external data sources like Excel or databases. 
- Security Testing: Test for vulnerabilities like SQL injection. 
- Load Testing: Simulate concurrent users to evaluate API performance. 

Best Practices for SoapUI: 
- Use Groovy scripting to create custom logic for complex scenarios. 
- Automate test execution by integrating SoapUI with Jenkins or other Continuous Integration (CI) tools. 
- Check that WSDL or API specifications are always up to date to avoid testing obsolete APIs.

Question: What’s REST Assured, and why is it preferred by SDETs?
Answer: REST Assured is a Java library that simplifies writing automated tests for REST APIs. It integrates with popular testing frameworks like JUnit and TestNG, making it useful for SDETs familiar with Java. 

How to Get Started with REST Assured: 
- Set Up REST Assured: Add the REST Assured dependency in your Maven pom.xml or Gradle build file

 - Write Basic Tests: Create a test class and use REST Assured methods to send API requests and validate responses. Example:

import io.restassured.RestAssured;

import static io.restassured.RestAssured.*;

import static org.hamcrest.Matchers.*;

// connect with me in LinkedIn at https://www.linkedin.com/in/inderpsingh

public class ApiTest {

    @Test

    public void testGetUser() {

        given().

            baseUri("https://api.example.com").

        when().

            get("/user/1").

        then().

            assertThat().

            statusCode(200).

            body("name", equalTo("John Doe"));

    }

}

- Parameterization: Use dynamic query or path parameters for flexible testing. Example:

given().

    pathParam("id", 1).

when().

    get("/user/{id}").

then().

    statusCode(200);

- Chaining Requests: Chain API calls for end-to-end scenarios. Example: Use the token from a login response in subsequent calls. 

Why Use REST Assured? 
- Combines test case logic and execution in a single programming environment. 
- Provides support for validations, including JSON and XML paths. 
- Simplifies testing for authentication mechanisms like OAuth2, Basic Auth, etc. 

Best Practices for REST Assured: 
- Follow Framework Design Principles: Integrate REST Assured into a test automation framework for reusability and scalability. Use Page Object Model (POM) for API resources. 
- Log API Requests and Responses: Enable logging to debug issues during test execution. 
Example: RestAssured.enableLoggingOfRequestAndResponseIfValidationFails();

Question: What are some examples of common API test cases?
Answer: Here are examples of API test cases for commonly encountered scenarios: 
- Validation of Response Status Code: Test that the API returns the correct HTTP status code. Example: For a successful GET /user/123 request, the status code should be 200. Tip: Include negative test cases like checking for 404 for non-existent resources. 
- Response Time Verification: Test that the API response time is within the acceptable limit. Example: For GET /products, the API should respond in less than 500ms. Tip: Automate response time checks for frequent monitoring. 
- Header Validation: Test if required headers are present in the API response. Example: Verify the Content-Type header is application/json. Tip: Include test cases where headers like Authorization are mandatory. 
- Pagination: Test that the API returns correct paginated results. Example: For GET /users?page=2&size=10, ensure the response contains exactly 10 users from page 2.
Tip: Validate totalPages or totalItems fields, if available. 
- Error Messages and Codes: Test appropriate error codes and messages are returned for invalid inputs. Example: Sending an invalid userId should return 400 with the message, "Invalid user ID". Tip: Test for edge cases like sending null or special characters.

Question: Can you provide sample test cases for authentication and authorization APIs?
Answer: Authentication and authorization are important components of secure APIs. Below are a few test cases: 
- Positive Case: Valid Login Credentials: Test that a valid username and password returns a 200 status with a token in the response.
Example: Request: POST /login

{ "username": "testuser", "password": "password123" }

Response:

{ "token": "abc123xyz" }

Validate token structure (e.g., length, format, expiration). 
- Negative Case: Invalid Credentials: Test that the invalid credentials return 401 Unauthorized. 401 means the request lacked valid authentication, while 403 means the user is authenticated but lacks permission.
Example: Request:

{ "username": "testuser", "password": "wrongpass" }

Response:

{ "error": "Invalid credentials" }

- Token Expiry Validation: Test that expired tokens return 401 Unauthorized or a similar error. Tip: Check token expiration logic by simulating delayed requests. 
- Role-Based Authorization: Test that users with insufficient permissions are denied access. Example: Admin user can POST /createUser. Guest user attempting the same returns 403 Forbidden. 
- Logout Validation: Test that the POST /logout endpoint invalidates tokens, preventing further use. Example: After logout, GET /user should return 401 Unauthorized.

Question: What are example test cases for CRUD operations?
Answer: CRUD operations (Create, Read, Update, Delete) are basic in API testing. Below are the examples: 
- Create (POST): Test Case: Validate successful creation of a resource. 
- Read (GET): Test Case: Verify fetching an existing resource returns correct details. 
- Update (PUT): Test Case: Validate updating an existing resource works as expected. 
- Partial Update (PATCH): Test Case: Confirm PATCH allows partial updates. 
- Delete (DELETE): Test Case: Validate successful deletion of a resource. 

Tips for CRUD Testing: o Use mock data for test environments to avoid corrupting production systems. o Check database states post-operations for consistency. o Validate cascading deletes for related entities.

Want to learn Test Automation, Software Testing and other topics? Take free courses for QA on this Software Testing Space blog at https://inderpsingh.blogspot.com/p/qa-course.html

Java Test Automation Interview Questions and Answers with Java code

Here are my Java Test Automation Interview Questions and Answers for SDETs, QA and Test Automation Architects. Read the interview questions for Java Test Automation on Java Fundamentals for Test Automation, Core Java Programming Skills for Test Automation, Java and Object-Oriented Design Patterns in Test Automation, Java Frameworks and Libraries for Automated Testing, Java Interview Questions for Automation Testing Roles, Java and Selenium WebDriver for UI Automation, Data-Driven Testing with Java and API Test Automation with Java.

If you want my complete set of Java Test Automation Interview Questions and Answers as a document that additionally contain the following topics, you can message me on my LinkedIn profile or send me a message in the Contact Us form in the right pane:
Intermediate Java Concepts for Test Automation, Advanced Java Techniques for Automation Testing, Building a Java Test Automation Framework, Best Practices in Java Automated Testing, Java for Test Automation Tips, Tricks, and Common Pitfalls, and FAQs and Practice Questions for Java Test Automation.

Question: Why is Java popularly used in test automation, and how does it benefit testing roles?
Answer: Java’s platform independence, extensive library support, and large community make it highly suited for test automation frameworks like Selenium, JUnit, and TestNG. Java works with object-oriented principles and error-handling mechanisms, allowing SDETs and QA testers to create modular, reusable, and maintainable tests.

Question: What are the advantages of using Java over other languages in automation testing?
Answer: Java has the following advantages:
- Strong Typing: Helps catch many potential type-related issues at compile time.
- Comprehensive Libraries: Useful for handling data, file I/O, and complex test scenarios.
- Concurrency Support: Enables multi-threading, making it useful for performance testing.
- Integration with Testing Tools: Java integrates with many automation tools.

Question: What are the key data types in Java, and how do they support automation?
Answer: Java has two main data types:
- Primitive Types (e.g., int, double, boolean) are used for simple operations like counting or asserting values in tests.
- Reference Types (e.g., String, Arrays, Lists) are used for handling collections of data or complex assertions.
Example: Checking form validation where multiple strings or arrays may need validation.

Question: How does control flow work in Java test automation in Java?
Answer: Control flow (using statements like if, for, while, switch) allows automated test scripts to make decisions and repeat actions. It can handle scenarios like:
- Conditional Validation: Validating if a user is logged in and running appropriate test steps.
- Looping: Iterating through data sets or UI elements to ensure thorough testing.
Example: 

Question: How can you use variables effectively in your test automation scripts?
Answer: Variables in Java can store test data (e.g., URLs, credentials) that might change across environments. They make scripts easy to update.

Question: What is the role of exception handling (try-catch) in automation?
Answer: Exception handling deals with unexpected events (like missing elements or timeouts) without halting the entire test suite. It allows graceful error handling and makes the test less flaky (more robust).
Example: 

Question: How can you write classes and objects in Java to create modular test scripts?
Answer: Classes encapsulate test functions, reducing code redundancy. Objects represent specific test cases or actions, helping testers organize code in reusable modules.
Example: 

Question: How can you use inheritance to simplify test case creation?
Answer: Inheritance allows a class to reuse fields and methods of another class, which is helpful for creating shared test functions.
Example: 

Question: What is polymorphism, and how can you use it to optimize test cases?
Answer: Polymorphism allows testers to use a common method in different ways, making scripts more flexible. For instance, a click() function can work on various UI elements.
Example: 

Question: What is java.util, and why is it important for testers?
Answer: The java.util package provides data structures (like ArrayList, HashMap) that are can handle collections of data in tests, such as lists of web elements or data sets.
Example: Using ArrayList to store a list of test data inputs. 

Question: How does java.lang help in test automation?
Answer: The java.lang package includes core classes like String, Math, and System, for tasks like string manipulation, mathematical operations, and logging in test automation.
Example: Generating a random number for unique input generation. 

Question: Can you name some methods in java.util.Date that are useful in test automation?
Answer: java.util.Date and java.time have methods for handling date and time, which can be important for scheduling tests or validating time-based features. Note: Prefer java.time (Java 8+) over java.util.Date for new code.
Example: Using LocalDate for date-based validation. 

Question: As an Automation Test Architect or Lead, what are some practical tips for SDETs and QA on Java fundamentals?
Answer: 1. Understand Data Types: Knowing when to use specific data types (int vs. double, ArrayList vs. LinkedList) can impact memory usage and test speed.
2. Write Reusable Methods: Encapsulate common actions (like logging in or navigating) in reusable methods to make tests more readable and maintainable.
3. Handle Exceptions: Use specific exception handling (NoSuchElementException, TimeoutException) to catch errors accurately, making test results more informative.
4. Use Libraries: Use java.util collections for handling data sets and java.lang for efficient code execution.

Want to learn more? View my Java Interview Questions and Answers videos:
- https://youtu.be/HBQxq1UUNAM
- https://youtu.be/1gRuQMhydgs
- https://youtu.be/e5BLn9IGrF0

 

Question: How is exception handling useful in test automation, and how does the try-catch mechanism work in Java?
Answer: Exception handling allows test automation scripts to handle unexpected situations gracefully, such as missing elements or timeout errors, without halting the complete test run. The try block contains code that might throw an exception, and the catch block handles it.
Example: 

Question: What is the role of the finally block in exception handling?
Answer: The finally block executes irrespective if an exception occurred or not. It’s useful for cleanup activities, such as closing a browser or logging out.
Example: 

Question: How can you create a custom exception for test automation in Java?
Answer: Custom exceptions are defined by extending the Exception class. They allow specific error messages or handling specific test failures.
Example: 

Question: How can you handle files in test automation, and which classes can you use in Java for this purpose?
Answer: File handling allows tests to read data inputs from and write results to files, supporting data-driven testing. The commonly used classes are FileReader, BufferedReader for reading, and FileWriter, BufferedWriter for writing. 

Example: Reading from a file 

Example: Writing to a file 

Question: How can you use file handling or data-driven testing?
Answer: By reading test data from external sources (e.g., CSV or text files), QA testers can parameterize tests, reducing hard-coded values and making tests work with multipledatasets.

Question: What are the advantages of using collections in test automation?
Answer: Collections, like ArrayList, HashSet, and LinkedList, are useful for managing dynamic data sets, such as lists of test cases or elements, with features like sorting, searching, and filtering.
Example: Using an ArrayList to store and iterate through test data 

Question: How can you use Maps for test data management in automation testing?
Answer: Maps store key-value pairs, making them useful for data like configurations or credentials where values can be retrieved by specific keys.
Example: Using a HashMap for storing and retrieving login credentials 

Question: What is the benefit of multi-threading benefit in test automation, especially for parallel execution?
Answer: Multi-threading allows concurrent test execution, reducing overall test execution time. In test automation, it allows tests to run in parallel, simulating multiple user interactions.

Question: What are the basic steps of implementing multi-threading in Java for parallel test runs?
Answer: Multi-threading in Java can be implemented by extending Thread or implementing Runnable. Each test case can be run as a separate thread, enabling simultaneous execution.
Example: Creating multiple threads for parallel tests 

Question: How can you use Executors to manage a pool of threads in Java?
Answer: The ExecutorService interface provides methods to manage a thread pool, allowing multiple tests to run concurrently while efficiently managing resources.
Example: Using Executors for parallel execution 

Question: What is the Page Object Model (POM), and why is it needed in test automation?
Answer: The Page Object Model is a design pattern where each web page in the application is mapped as a class with methods encapsulating actions users can perform on that page. It makes tests more readable and maintainable (by centralizing element locators and interactions in one place). You can view the working example of SeleniumJava POM implemented below.

Example: POM for a Login Page 

Question: What problem does the Singleton pattern solve, and how can you use it in test automation?
Answer: The Singleton pattern restricts the instantiation (meaning creating objects) of a class to one object. In test automation, it uses only one instance of the WebDriver during a test session, preventing resource conflicts and allowing better browser control.
Example: Singleton WebDriver instance 

Question: How can you use the Factory pattern in test automation?
Answer: The Factory pattern creates objects without specifying the exact class of object that will be created. It’s useful for managing browser-specific configurations by centralizing the logic for initializing different WebDriver instances.
Example: Factory pattern for WebDriver 

Question: How can you use the Strategy pattern, and how does it support data management in test automation?
Answer: The Strategy pattern defines a family of algorithms with interchangeability at runtime. It is useful for test automation where multiple strategies are needed to handle different types of data sources (e.g., CSV, database, JSON).
Example: Strategy pattern for test data input 

Question: How can the Strategy pattern manage different configurations in test automation?
Answer: The Strategy pattern allows dynamically switching between configurations (e.g., different test environments or data sets) by implementing different configuration strategies.

Question: What is Dependency Injection, and how does it work in test automation?
Answer: Dependency Injection (DI) is a design pattern where an object receives its dependencies from an external source rather than creating them. DI improves test reusability and flexibility by allowing dependencies like WebDriver or configurations to be injected instead of hardcoded.
Example: Dependency Injection in test 

Question: How does Inversion of Control (IoC) differ from Dependency Injection, and how does it work in Java testing frameworks?
Answer: IoC is a bigger concept where control is transferred from the object to an external source, while DI is a specific implementation of IoC. In Java testing frameworks like Spring, IoC containers manage dependencies, allowing components to be loosely coupled and more modular.
Example: IoC with Spring Framework in test automation 

Question: What are JUnit and TestNG, and why are they so popular in Java test automation?
Answer: JUnit and TestNG are Java testing frameworks for unit, integration, and end-to-end testing. JUnit is simple (view JUnit with Selenium Java demonstration here) and widely used for unit tests. TestNG has advanced features like parameterized tests and parallel execution.
Example: JUnit Test 

Example: Basic TestNG Test 

Question: How do JUnit and TestNG support different testing scopes (unit, integration, and UI)?
Answer: JUnit needs a minimal setup, while TestNG has features like parallel execution and dependency-based test configuration. Both frameworks are compatible with Selenium for browser-based tests.

Question: What are the functionality differences between JUnit and TestNG?
Answer:
- Annotations: TestNG offers more annotations (@BeforeSuite, @AfterSuite) compared to JUnit.
- Parameterized Tests: TestNG provides @DataProvider for parameterized tests, and modern JUnit (JUnit 5) supports parameterized tests natively via @ParameterizedTest with providers such as @ValueSource and @CsvSource.
- Parallel Execution: TestNG supports parallel execution and suites, while JUnit may need additional configuration first.
- Exception Handling: TestNG allows configuring expected exceptions and retry mechanisms easily.

Question: In which test automation projects, would you choose TestNG over JUnit?
Answer: TestNG is preferred for complex test suites that require parallel execution, detailed configuration, or dependency management among tests. For simple projects with unit tests, JUnit is more efficient due to its basic features.

Question: Why are Maven and Gradle needed for Java test automation?
Answer: Maven and Gradle are build automation tools that manage project dependencies, compile source code, and run tests. They allow adding libraries (like Selenium or REST-assured) by automatically downloading dependencies.

Question: How do you add dependencies in Maven and Gradle for a test automation project?
Answer: In Maven: Add dependencies in the pom.xml file under the <dependencies> tag. In Gradle: Use the dependencies block in the build.gradle file.
Example: Adding Selenium dependency in Maven 

Example: Adding Selenium dependency in Gradle 

Question: How do Maven and Gradle improve test automation workflows?
Answer: Maven and Gradle handle dependency conflicts, generate reports, and automate builds. They also support plugins to run tests, generate reports, and integrate with CI/CD systems like Jenkins, optimizing test automation workflows.

Question: What is mocking in test automation, and how does Mockito support it?
Answer: Mocking simulates the behavior of dependencies, such as databases or web services, to isolate the functionality under test. Mockito is a popular library that allows you to create and control mock objects in Java tests, making it easier to write tests that don't rely on external dependencies.
Example: Basic Mockito Mocking 

Question: How is stubbing different from mocking?
Answer: Stubbing is a specific type of mocking in which predefined responses are set up for particular method calls. While mocking controls the behavior of objects in tests, stubbing defines what happens when certain methods are invoked.

Question: How does Mockito help in writing isolated unit tests?
Answer: Mockito has functions like when, verify, and spy that allow fine-grained control over test dependencies, letting you validate your system, without the need for external systems or real data.

Question: Write a Java method to reverse a string. Why is it relevant for the SDET role?
Answer: Reversing a string is used in test automation for validating outputs, URL parsing, or log validation in automation scripts.
Example:

public String reverseString(String str) {

 return new StringBuilder(str).reverse().toString();

}

Question: Write a program to check if a number is prime.
Answer: 

Question: How you would design a test framework that validates login functionality?
Answer: A framework includes a modular test structure, page objects for UI elements, and reusable functions for key actions like login, logout, and navigation. I would use configuration files for environment-specific values like URLs and credentials.
Example:
- Framework Structure: Page Objects (LoginPage, HomePage) for element management.
- Test Methodology: Implement assertions to validate login success or failure.
- Test Data: Parameterize test data using JSON or an external CSV file.

Question: How would you handle a scenario where a test case intermittently fails due to network latency?
Answer: By implementing retry logic in the test framework to rerun a failed test a specified number of times before marking it as a failure. Additionally, I would use waits (explicit or fluent waits) instead of static delays to dynamically handle loading times.
Example: View Selenium Java waits demonstration in my Selenium Java Alerts video here.

Question: How would you identify and resolve a NullPointerException in a test script?
Answer: NullPointerException occurs when trying to use a null object reference. To resolve it:
- Use null checks before accessing objects.
- Debug and check initialization of objects.
- Use Optional to handle potential nulls more safely.
Example: Debugging Code 

Question: What approach would you take if your test fails due to StaleElementReferenceException in Selenium?
Answer: This exception occurs if the element is no longer attached to the DOM. To fix:
- Use try-catch with a re-fetch of the element.
- Implement explicit waits to allow the DOM to refresh.
- Use the ExpectedConditions.refreshed method to retry locating the element.
Example:

WebDriverWait wait = new WebDriverWait(driver, 10);

wait.until(ExpectedConditions.stalenessOf(element));

Question: How would you optimize tests that involve frequent database queries in a test automation suite?
Answer: Caching and efficient database handling reduce latency and speed up test execution. To optimize:
- Use connection pooling for efficient database access.
- Cache frequently used data to minimize repetitive database calls.
- Batch database requests when querying or updating multiple records.
Example: Example Code for Caching 

Question: How would you structure tests to validate complex workflows like e-commerce checkout?
Answer: For complex workflows:
- Use a modular structure with page objects for each step (e.g., LoginPage, ProductPage, CheckoutPage).
- Parameterize test data for items and quantities.
- Implement data-driven tests to validate different scenarios (e.g., cart with multiple items, invalid coupon). 

Question: How do you set up a basic Selenium WebDriver project in Java?
Answer: Start by adding Selenium dependencies (e.g., via Maven), initializing WebDriver, and creating a basic test script.
Steps:
1. Add Selenium dependencies in the pom.xml if using Maven.
2. Initialize WebDriver.
Example:

WebDriver driver = new ChromeDriver();

driver.get("https://inderpsingh.blogspot.com/");

Question: Explain the use of findElement, click, and sendKeys methods in Selenium WebDriver.
Answer: These are methods in Selenium for interacting with UI elements. The examples of Selenium WebDriver methods are shown in my highly popular Selenium Java Questionsand Answers video at https://youtu.be/e5BLn9IGrF0. 

Examples:

WebElement button = driver.findElement(By.id("submit"));

button.click();

driver.findElement(By.id("username")).sendKeys("testUser");

Question: How do you handle errors if an element is not found on the page?
Answer: Exception handling prevents test failures, especially when elements load dynamically. I would use try-catch for exception handling with WebDriver and implement waits to allow the page to load fully.
Example: 

Question: What are dynamic web elements, and how do you handle them in Selenium?
Answer: Dynamic web elements change their properties (e.g., IDs or class names) between page loads. Handling dynamic elements is needed for web testing, as modern web applications often have dynamically generated content. XPath and waits help manage these elements and reduce flaky tests. Use relative locators, XPath, CSS selectors, or dynamic waits (e.g., explicit waits) to handle such elements. View the SelectorsHub dynamic locators video here to know how to get the reliable locators.

Question: How would you handle a scenario where multiple elements have the same attributes (e.g., same class name)?
Answer: Use findElements to locate all matching elements and select the desired one based on index or other distinguishing characteristics.

Question: What are the best practices for writing maintainable Selenium tests in Java?
Answer: Key practices include using Page Object Model (POM), parameterizing data, and implementing reusable methods.
Examples:
1. Page Object Model (POM): Create a class for each page and manage elements and actions there. 

Parameterizing Test Data: Use external data files (CSV, JSON) to store test data, which makes tests more flexible and reusable. 

Reusable Utility Methods: Create utility methods for repetitive actions (e.g., wait for an element, scroll, etc.).
 

Question: How do you reduce tests "flakiness" against minor UI changes?
Answer: Use flexible locators (like relative XPath or CSS selectors) and avoid brittle locators tied to frequently changing attributes (like IDs). Implement custom retry mechanisms and avoid hard-coded waits in favor of explicit waits.

Question: How would you organize test code for a large-scale UI test automation project?
Answer: Organize the project with:
- Modular structure for tests and reusable functions.
- Separate packages for pages (Page Objects), test cases, utilities, and configurations.
- TestNG or JUnit for managing and running tests.
- Reporting with tools like ExtentReports or Allure for detailed insights.

Question: How can you read data from an Excel file in Java for test automation?
Answer: The Apache POI library allows us to interact with Excel files. Use XSSFWorkbook for .xlsx files and HSSFWorkbook for .xls files. You can view my video on Selenium Java Excel Read here.
Example: 

Question: How can you write data to an Excel file in Java using Apache POI?
Answer: To write data to Excel, we use XSSFWorkbook to create a new workbook and specify cell values.
Example: Writing data to Excel files allows us to store test results or logs, supporting validation and reporting in automated test suites. 

Question: How can you set up a parameterized test in JUnit?
Answer: Parameterized tests allow multiple data sets to be tested using a single test method. JUnit allows parameterized tests using @ParameterizedTest with a @ValueSource or custom provider method.
Example: Example of Parameterized Test Using JUnit 5 

Question: How can you do parameterized testing in TestNG?
Answer: TestNG provides @DataProvider to supply parameters to test methods. Using DataProvider in TestNG allows for parameterized tests with multiple test inputs.
Example: Example of Using DataProvider in TestNG 

Question: How can you read JSON test data in Java?
Answer: Libraries like Jackson or Gson can parse JSON data into Java objects for testing.
Example: Example Using Jackson to Parse JSON Data 

Question: How can you use XML for test data management in Java tests?
Answer: The javax.xml.parsers package provides utilities for XML parsing in Java.
Example:

import javax.xml.parsers.DocumentBuilderFactory;

import org.w3c.dom.*;

import java.io.File;

public class XMLReader {

 public void readXML(String filePath) throws Exception {

 Document doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(new File(filePath));

 doc.getDocumentElement().normalize();

 NodeList nodeList = doc.getElementsByTagName("data");

 for (int i = 0; i < nodeList.getLength(); i++) {

 Element element = (Element) nodeList.item(i);

 System.out.println("Element Data: " + element.getTextContent());

 }

 }

}

Question: What are the design patterns that you can use in data-driven testing?
Answer: Design patterns for data-driven testing include the Factory Pattern and Singleton Pattern.
- Factory Pattern: Used to create test data objects dynamically based on test needs.
- Singleton Pattern: It uses only one instance of a data provider class exists to manage data centrally across tests.

Question: What are best practices for managing data-driven tests in Java?
Answer: Key best practices include:
- Externalize Test Data: Use external files (JSON, XML, Excel) for data instead of hardcoding it into scripts.
- Modularize Data Access Code: Create reusable methods for data access to reduce redundancy.
- Centralize Data: Centralizing data in one repository simplifies maintenance.

If you have questions, you can message me after connecting with me on LinkedIn at https://www.linkedin.com/in/inderpsingh/

Question: What is REST Assured, and why is it popular for Java-based API testing?
Answer: REST Assured is a Java library specifically designed for testing RESTful APIs. It simplifies HTTP requests and responses handling, using concise syntax for validating responses. REST Assured integrates with JUnit and TestNG, making it popular for API testing.
Example: Basic GET Request with REST Assured 

Question: How can you use HttpClient for API testing in Java?
Answer: Apache HttpClient is a library that supports more complex HTTP operations. It’s suitable for test scenarios where we need custom headers, cookies, or advanced request configurations.
Example: Example of GET Request Using HttpClient:

import org.apache.http.HttpResponse;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClients;

import java.io.BufferedReader;

import java.io.InputStreamReader;

public class HttpClientExample {

 public void sendGetRequest() throws Exception {

 CloseableHttpClient client = HttpClients.createDefault();

 HttpGet request = new HttpGet("https://jsonplaceholder.typicode.com/posts/1");

 HttpResponse response = client.execute(request);

 BufferedReader reader = new BufferedReader(new InputStreamReader(response.getEntity().getContent()));

 String line;

 while ((line = reader.readLine()) != null) {

 System.out.println(line);

 }

 client.close();

 }

}

Question: How can you build a basic API test scenario for a POST request using REST Assured?
Answer: REST Assured allows construction of POST requests to verify data creation endpoints. For testing purposes, JSON data can be sent in the request body.
Example: POST Request Using REST Assured 

Question: How can you chain multiple API requests in REST Assured?
Answer: REST Assured supports response extraction and chaining, enabling us to use the result of one request as input for another. This is useful for test flows that require dependencies across API calls.
Example: Chaining API Requests 

Question: How can you validate JSON responses in REST Assured?
Answer: REST Assured offers easy-to-use syntax to validate JSON responses. The body method lets us directly assert JSON path values.
Example: JSON Validation 

Question: How can you validate XML responses in Java with REST Assured?
Answer: REST Assured can parse XML responses, enabling XPath expressions for field-level validation.
Example: XML Validation Using REST Assured 

Question: How can you handle authentication for API tests in REST Assured?
Answer: REST Assured supports various authentication mechanisms, including basic, OAuth, and API keys. REST Assured also supports token-based authentication for test scenarios with OAuth or API keys.
Example: Basic Authentication 

Question: How can you add headers and cookies to API requests in REST Assured?
Answer: REST Assured allows to specify headers and cookies, allowing us to test complex API calls.
Example: Adding Headers and Cookies 

Question: How can you use REST Assured to validate headers in a response?
Answer: REST Assured allows to assert headers in the response using the header method.
Example: Response Header Validation 

Need quick revision? View the following videos:
- https://youtu.be/HBQxq1UUNAM
https://youtu.be/1gRuQMhydgs
https://youtu.be/e5BLn9IGrF0
https://youtu.be/KTrde1KZPjw
https://youtube.com/shorts/TCidbCMUBiM
https://youtube.com/shorts/t1sfVp-3xDM
https://youtube.com/shorts/BjzJwg9QTyQ
https://youtube.com/shorts/3axOjPJYrw8
https://youtu.be/49BnC2awJ1U
https://youtu.be/2G3of2qRylo

Want to learn more? In order to get my full set of Java Test Automation Interview Questions and Answers with Java code, you are welcome to message me by connecting or following me on LinkedIn. Thank you!