1. What is API?

API stands for Application Programming Interface. APIs are mechanisms that enable two software components to communicate with each other using a set of definitions and protocols. Example of an API is the Twitter API. It enables developers to access and interact with Twitter’s platform programmatically. Developers can use the Twitter API to retrieve tweets. They can also post tweets, search for tweets, and manage user accounts. Additionally, developers can perform various other actions related to Twitter’s services.

API architecture is usually explained in terms of client and server. The application sending the request is called the client, and the application sending the response is called the server.

2. What is API Testing?

API testing is a type of software testing that focuses on verifying the functionality, reliability, performance, and security of an application programming interface (API). Since APIs don’t have a GUI, API testing is performed at the message layer of the system.

3. What are the advantages of API Testing?

1. Independent of UI – API testing can detect issues in the early stages of development. It is independent of the GUI. This allows for timely resolution and prevents more significant problems later on.

2. Faster Execution – API tests typically take less time than functional GUI testing. GUI testing takes longer because the web components need to be polled.

3. Integration with CI/CD Pipelines – API testing can be easily automated. It can be integrated into continuous integration (CI) pipelines. This enables rapid feedback and faster release cycles.

4. Ensures Security – API testing allows for thorough security testing. It includes authentication, authorization, data encryption, and protection against common security vulnerabilities.

5. Language Independent – An API test uses XML or JSON to exchange data. These transfer modes are not language-dependent; therefore, you can use any programming language when writing automated tests for your API.

4. How is API testing different from UI testing?

*API Testing*	*UNIT Testing*
API is owned by QA team	Unit testing is owned by development team
API testing primarily involves testing the functionality of APIs without knowledge of their internal implementation details, making it a form of black-box testing.	Unit Testing is white box testing. In unit testing, the tester typically has knowledge of the internal workings of the code being tested.
It tests the integration and interaction between multiple units or components, typically involving larger portions of the codebase.	Unit tests are more granular and targeted, verifying the behavior of individual functions or methods.
It often involves testing the interaction between different components, services, or systems, including external dependencies such as databases or third-party APIs.	Unit tests typically focus on testing a single unit of code in isolation from its dependencies. It uses the techniques like mocking, stubbing, dependency injection.
API Testing can be conducted in various environments, including development, staging, and production, as long as the APIs are accessible.	Unit Tests can be generally conducted within the development environment or on developers’ local machines.

5. What are the types of APIs?

SOAP APIs

These APIs use Simple Object Access Protocol. Client and server exchange messages using XML. This is a less flexible API that was more popular in the past.

RPC APIs

These APIs are called Remote Procedure Calls. In RPC communication, the client program sends a request to the server program, specifying the procedure or function to be executed and any required parameters. The server receives the request, executes the specified procedure, and sends back the result to the client.

RPC APIs can use various communication protocols for transmitting data between the client and server, including HTTP, TCP/IP, and UDP. Examples of RPC APIs include XML-RPC, JSON-RPC, gRPC, and Microsoft’s Distributed Component Object Model (DCOM).

Websocket APIs

Websocket API is another modern web API development that uses JSON objects to pass data. A WebSocket API supports two-way communication between client apps and the server. The server can send callback messages to connected clients, making it more efficient than REST API.

REST APIs

These are the most popular and flexible APIs found on the web today. The client sends requests to the server as data. The server uses this client input to start internal functions and returns output data back to the client.

GraphQL APIs

GraphQL is a query language and runtime for APIs developed by Facebook. GraphQL APIs enable clients to request only the data they need using a single endpoint and a flexible query syntax. They provide more flexibility and efficiency compared to traditional REST APIs for fetching and manipulating data.

Database APIs

These APIs provide access to databases, allowing applications to perform CRUD (Create, Read, Update, Delete) operations on data stored in the database. Examples include JDBC (Java Database Connectivity) for Java applications and SQLAlchemy for Python applications.

6. Mention a few common tools used for API testing.

1. Postman: A popular tool for designing, testing, and documenting APIs. It provides a user-friendly interface for sending requests, inspecting responses, and automating tests.

2. Swagger: A widely used tool for designing, building, and documenting RESTful APIs. It provides a visual editor for designing API contracts and generating documentation.

3. SoapUI/ReadyAPI: It is a comprehensive tool for testing SOAP and RESTful APIs. It supports various protocols, message formats, and authentication methods and provides advanced testing features such as data-driven testing and security testing.

4. JMeter: Apache JMeter is a popular open-source tool for performance testing and load testing of web applications, including APIs. While it’s primarily known for its performance testing capabilities, JMeter can also be used for API testing by sending HTTP requests and analyzing responses.

5. REST Assured: REST Assured is a Java library for testing RESTful APIs. It provides a domain-specific language (DSL) for writing expressive and readable API tests, making it popular among Java developers for automated API testing.

7. What is the difference between RESTful API and SOAP API?

*Rest API*	*SOAP API*
RESTful API follows the principles of Representational State Transfer (REST) and typically uses HTTP methods such as GET, POST, PUT, and DELETE for operations.	SOAP is a protocol with specific requirements and infrastructure. It involves strict rules for data exchange and the structure of messages.
Supports multiple data formats such as *JSON, XML, HTML, and plain text.* JSON is the most commonly used format due to its simplicity and ease of use with JavaScript.	Primarily uses XML to format messages. The structure of the message is heavyweight and includes elements like Envelope, Header, and Body.
Typically uses HTTP/HTTPS for communication.	Uses *HTTP/HTTPS, SMTP,* and other protocols.
It is *faster* and more *scalable* due to its *stateless* nature and caching capabilities.	It is generally slower due to the verbosity of XML and the need to process extensive SOAP headers.
*Custom security* features like OAuth, JWT.	*Built-in security* features like WS-Security for secure messaging.
Best suited for *web and mobile applications* where performance, scalability, and simplicity are required.	Ideal for *enterprise applications* that require high security, reliability, and compliance with strict protocols.

8. What is an API endpoint?

An API endpoint is a specific URL that is exposed by an API to allow applications to interact with a system by performing various operations, such as creating, reading, updating, or deleting data. Each endpoint represents a unique path to a resource or a set of resources within the system that the API provides access to.

Characteristics of API Endpoint

URL Path: A specific URL for accessing resources or performing actions in an API. Example: “https://api.example.com/users“
HTTP Methods: Different methods (GET, POST, PUT, DELETE) define actions on the endpoint.
Parameters: Endpoints can include query, path parameters, headers, and request bodies. Example: “https://api.example.com/users?page=2&limit=20“ uses query parameters to paginate the list of users.
Responses: Contain status codes and data returned by the server.

9. What are the core components of an HTTP request?

An HTTP request contains five key elements:

An action showing HTTP methods like GET, PUT, POST, and DELETE.

Uniform Resource Identifier (URI), which is the identifier for the resource on the server.

https://www.qaautomation.expert

HTTP Version, which indicates HTTP version, for example-HTTP v1.1.

Request Header, which carries metadata (as key-value pairs) for the HTTP Request message. Metadata could be a client (or browser) type, format supported by the client, format of a message body format, cache settings, and so on.

Host: www.example.com
User-Agent: Mozilla/5.0
Accept: text/html

Request Body, which indicates the message content or resource representation.

  {
     "username": "exampleuser",
     "password": "examplepassword"
   }

9. Mention common HTTP methods used in API testing

GET: Used to retrieve data or resources from an API.
POST: Used to create new data or resources on an API.
PUT: Used to update existing data or resources on an API.
DELETE: Used to delete data or resources from an API.
PATCH: Used to update existing data or resources on an API partially.

10. What is the difference between POST and PUT?

*POST*	*PUT*
It is used to create a new resource on the server.	It is used to update an existing resource or create one if it does not exist (depending on the context and implementation).
It is not idempotent. Making the same `POST` request multiple times can result in multiple resources being created with different identifiers.	It is Idempotent. Making the same `PUT` request multiple times will have the same effect as making it once. The resource will be created or updated to the same state.

11. What is the purpose of HTTP status codes in API testing?

The purpose of HTTP status codes in API testing is to indicate the outcome of an API request that whether the request is successfully processed, encountered an error or needs further action. Status codes are three-digit numbers included in the response message from the server to provide information about the result of the request.

HTTP status codes clearly communicate the outcome of an HTTP request. They enable clients and APIs to understand the result of their interactions without ambiguity.

1xx (100 – 199): The response is informational
2xx Success: The request was successfully received, understood, and accepted (e.g., 200 OK, 201 Created).
3xx Redirection: Further action is needed to fulfill the request (e.g., 301 Moved Permanently, 302 Found).
4xx Client Errors: The request contains incorrect syntax or cannot be fulfilled (e.g., 400 Bad Request, 401 Unauthorized).
5xx Server Errors: The server failed to fulfill a valid request (e.g., 500 Internal Server Error, 503 Service Unavailable).

12. What is the purpose of authentication in API testing?

Authentication in API testing is a critical component that ensures secure and controlled access to the API endpoints.

Authentication prevents unauthorized users or systems from accessing the API, thereby protecting sensitive data and operations. Ensures that data is only accessible to authenticated users, protecting it from unauthorized exposure.

Supports compliance with regulations that require user authentication, such as GDPR, HIPAA, and others.

13. What are some common authentication methods used in API testing?

1.Basic Authentication: This involves sending the username and password as part of the API request headers, encoded in base64 format.

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

2. Token-Based Authentication: This method issues a token to the client after successful authentication. The client then includes this token in subsequent API requests for authorization.

3. OAuth: This is a widely used authorization framework. It allows for the delegation of access rights from one entity to another. Credentials are not shared. It uses access tokens obtained via authorization servers.

4. API Keys: It is simple tokens that map to a specific user or application. It is sent as a header, query parameter, or part of the request body.

 x-api-key: YOUR_API_KEY

14. What are the different types of error responses in API testing?

1. HTTP error status codes: These are standard HTTP status codes, such as 4xx and 5xx codes, that indicate errors in the API request or response. Some of the examples are

400 Bad Request: The server could not understand the request due to invalid syntax. Possible reasons include malformed request syntax, invalid request message framing, or deceptive request routing.

401 Unauthorized: The request requires user authentication. This means the request lacks valid authentication credentials for the target resource.

403 Forbidden: The server understood the request but refuses to authorize it. This is usually due to insufficient permissions.

404 Not Found: The server cannot find the requested resource. This could mean the endpoint is incorrect or the resource has been deleted.

405 Method Not Allowed: The request method is known by the server but has been disabled and cannot be used. For example, a request method is not supported by that resource.

409 Conflict: There is a conflict with the current state of the resource. This code is used in situations where the request could not be processed because of conflict in the request.

429 Too Many Requests: The user has sent too many requests in a given amount of time (“rate limiting”).

2. Custom error responses: These are custom error messages or error objects returned by the API in case of errors or exceptions. These custom responses provide meaningful and detailed information that helps users and developers understand the nature of the error, the possible cause, and potential ways to resolve it. Example: Providing guidance like “Invalid input: Email field cannot be empty” is more helpful than a vague error message.

15. What is API mocking, and why is it used in API testing?

API mocking simulates the behavior of an API endpoint during testing. It does this without actually invoking the real API. This mock API can be configured to return predefined responses for specified requests. API mocking is particularly useful in various scenarios for both development and testing purposes.

1. Independent Development: Mock APIs allow front-end developers to work independently from back-end developers. They can simulate responses from the back end before the actual API is fully developed or functional.

2. Cost Management: When dealing with third-party APIs that bill based on usage, it can be cost-effective to use mock APIs during development. This approach reduces unnecessary expenses.

3. Simulation of Edge Cases: Mocking can be used to simulate different scenarios, including error cases and rare conditions that may be complex to reproduce with the actual API.

16. How do you perform load testing on APIs?

Load testing on APIs can be performed by simulating a large number of concurrent users or requests to the API endpoint using load testing tools or frameworks. The goal is to ensure that the API remains responsive and functional under stress.

Tools such as JMeter, Gatling, and k6 are popular open source tool for load testing APIs.

Tools like LoadRunner, BlazeMeter, and NeoLoad offer advanced features and support for various protocols.

Load Testing is used to identify performance bottlenecks, such as slow database queries, resource contention, or inefficient code. Implement fixes or optimizations based on the findings and rerun load tests to verify improvements.

Integrate load testing into the continuous integration/continuous deployment (CI/CD) pipeline to run tests automatically with each release.

Generate detailed reports summarizing the test results, including metrics, observations, and insights.

17. What is API security testing, and why is it important?

API security testing is a process of carefully evaluating API endpoints to identify and remediate vulnerabilities such as fuzzy input, parameter tampering, or injection attacks.

Why is API Security Testing Important?

1.Protection of Sensitive Data: APIs often handle sensitive information (user data, payment details). Security testing ensures compliance with data protection laws (e.g., GDPR, HIPAA). This protects data integrity and avoids potential reputational damage and the loss of customer trust.

2.Ensuring Service Availability: Malicious actors can exploit vulnerabilities to launch Denial-of-Service (DoS) attacks. They can overwhelm your APIs, making them unavailable to legitimate users. Securing APIs helps prevent downtime or service interruptions caused by security incidents.

3. Improving Stakeholder Trust: Customers and partners entrust the company with their data when they interact with their APIs. Regular security testing demonstrates your commitment to data protection, strengthening business relationships, and fostering customer confidence in your services.

18. What are the common security vulnerabilities found in API?

1. Injection Attacks: Attackers insert malicious code into the requests to manipulate the APIs’ intended behavior. SQL Injection, Host-Header Injection, and Command Injection are some of the most common attacks.

2. Brute Force Attacks: These attacks involve attempting various combinations of user credentials to gain unauthorized access. XML-RPC can be easily leveraged as an entry point for attacks and can execute multiple login attempts rapidly, leading to brute-force attacks.

3. Session Management Issues: Inadequate Session Management issues can lead to Authorization vulnerabilities.

4. Cross-Site Scripting (XSS): Injecting malicious scripts into API responses that can be executed in the client’s browser. An attacker injecting JavaScript into a response that steals session cookies.

5. WSDL Exposure: If the WSDL file is exposed to the attackers, they can view detailed information about the API structure. This information includes the operations. This allows attackers to craft more targeted attacks.

6. Cross-Site Request Forgery: This attack tricks a user into unknowingly executing unwanted actions. It happens on a web application where they are authenticated. It leverages the trust that a website has in the user’s browser. This can result in unauthorized actions like changing account settings, transferring funds, or deleting data.

7. Introspection Attack: It exploits an API’s introspection endpoint to gather information about access tokens, exposing sensitive details that attackers can use to compromise security. Introspection endpoints are designed to validate and retrieve metadata about tokens, such as their scopes, expiration, and the user they represent. If improperly secured, attackers can leverage them to gain unauthorized access or manipulate token data.

19. How to perform API Security testing?

1.SQL Injection – SQL Injection attacks are successful when the database processes the unsanitized API input. Hence, testing the REST API for any SQL Injection bugs is important. Try providing SQL commands in the input like:

'or 1=1--
"and 1=1--

2. Command Injection: Various OS commands can also inject API inputs, which are then executed on the server. However, the commands for different Operating systems(Windows, Linux, etc.) would differ. For Example, Redirecting output or appending data to files.

echo "malicious" >> /var/www/html/index.html

rm file.txt; cat /etc/passwd

The shell executes rm file.txt, deleting file.txt from the system. After deleting the file, the shell executes cat /etc/passwd, displaying the contents of the /etc/passwd file in the terminal.

3. Authentication Testing – Test whether the API properly implements authentication. Try to access the endpoint without using the authentication or invalid credentials.

JWT: Ensure tokens are signed, valid, and not modifiable

Basic Authentication: Validate if credentials are encrypted.

OAuth2/OpenID Connect: Verify token management (generation, expiration, and revocation).

4. Authorization Testing – Make sure that the users can only access resources they are authorized for. Test role-based access control (RBAC) or permission-based controls.

5. Rate Limiting and Throttling – Rate Limiting is a process of limiting the number of requests that can be sent to an API within a specific time. Testing for it means verifying that all the limits are properly set and enforced on all APIs. Simulate a high volume of requests to test the API’s resilience against Distributed Denial of Service (DDoS) attacks.

6. Discovering Zombie APIs – Zombie APIs are old or unused APIs that are still active but not updated or maintained. As they are not maintained, zombie APIs can lead to security risks and can be exploited for vulnerabilities.

Common Tests to Assess Zombie APIs:

Test for data accessed by zombie APIs(user data, financial data, etc.)
Test for Authentication and Authorization.
Test for weak encryption implementation.
Test for known vulnerabilities or CVEs.

20. What is the purpose of the request and response headers in API testing?

Request and response headers in API testing are used to transmit additional information about the request or response. Request headers can be used to specify a content type, authentication, caching, language preferences, etc.

Headers like Authorization include tokens, API keys, or credentials.
Specify the desired data format for the request or response.
Control or bypass caching mechanisms.

Response headers are sent by the server to the client, containing metadata about the response and instructions for handling it.

Specify the format and encoding of the response body.
Provide caching policies for the client to optimize performance.
Inform the client about rate limits or remaining quota.
Specify which origins are allowed to access the resource.

21. What is the purpose of query parameters in API testing?

Query parameters in API testing are used to pass additional parameters in the URL of an API request. These parameters are used to customize the behavior of the API request, such as filtering, sorting, or paginating results.

Pagination – APIs use query parameters to manage large datasets by breaking them into smaller chunks (pages).

https://api.example.com/items?page=2&limit=50

It returns the second page of results with 50 items per page.

Filtering Data – Query parameters are commonly used to filter the data returned by an API.

https://api.example.com/products?category=electronics&price<1000

It will display products in the “electronics” category with a price less than $1000.

22. What are the major challenges faced in API testing?

Output verification and validation – APIs can return responses in different data formats like JSON, XML, or plain text. Parsing and validating these formats might require additional effort.

Security Tokens – APIs may require various types of authentication, such as OAuth, API keys, or JWT tokens. Managing and automating the generation and use of these tokens can be complex.

Version Management – Testing different versions of the API and ensuring backward compatibility can become complex, especially if multiple versions are in active use.

External Dependencies – When integrating with third-party APIs, there can be challenges related to their availability, reliability, and version changes over which testers have little control.

Setting Up the Test Environment – APIs often depend on other services or databases. Setting up a fully operational test environment that mimics production can be challenging.

23. What are the testing methods that come under API testing?

1. Unit Testing: It involves testing the smallest functional parts of the API, such as individual endpoints, services, or methods, to ensure they work as expected. Unit tests are typically written to validate the behavior and functionality of your code in isolation.

2. Functional Testing: It ensures that the API functions as expected and meets the requirements and specifications. It verifies responses for various inputs and parameters, HTTP status code.

3. Integration Testing: It tests the interaction between different modules or services to ensure they work together as intended. It verifies that APIs properly communicate with other APIs or systems.

4. Load Testing: It evaluates the API’s performance under a specific load to determine its behavior under normal and peak conditions.

5. Stress Testing: Subjects the API to extreme conditions to evaluate how it handles high traffic, large data volumes, or limited resources.

6. Fuzz Testing: Sends random or unexpected data to the API to see how it responds. Automatically generating malformed or random inputs to test the API’s robustness.

7. Security Testing: It Ensures that the API is secure and can protect data from unauthorized access or attacks. Checks for vulnerabilities such as SQL injection, XSS, and other attack vectors.

8. Usability Testing: Ensures that the API is user-friendly and its endpoints are easy to use. Reviewing API documentation and testing the ease of making requests and interpreting responses.

9. Compliance Testing: Verifies that the API adheres to specific standards, regulations, and guidelines. Ensures adherence to industry standards such as REST, SOAP, or specific compliance requirements (e.g., GDPR, HIPAA).

10. Penetration Testing: Simulates attacks on the API to identify security weaknesses. Identifies vulnerabilities that could be exploited by attackers.

11. Regression Testing: Ensures that recent changes to the API do not affect existing functionality. Running a comprehensive set of tests after a new feature is added to ensure existing functionalities are intact.

24. Why is API testing considered as the most suitable form for Automation testing?

API testing is now preferred over GUI testing and is considered as most suitable because:

1. APIs serve as the communication layer between different software components. By testing APIs, issues can be identified early in the development process before the UI is developed.

2. APIs tend to be more stable and less prone to frequent changes compared to the user interface (UI). This stability makes API tests more reliable and less likely to break with minor updates.

3. API tests are generally faster to execute. They are quicker because API tests do not require the overhead of rendering the user interface, unlike UI tests.

4. API tests do not depend on the UI, they can be executed even when the UI is not available or under development. This independence allows for continuous testing throughout the development cycle.

5. API tests focus on the core business logic and data layer, which are crucial for the functionality of the application. This ensures that the critical components are thoroughly tested.

6. APIs are ideal candidates for automation within CI/CD pipelines. Automated API tests can be seamlessly integrated into build and deploy processes, providing rapid feedback and ensuring continuous testing.

25. What type of bugs would often found in API testing?

1. Incorrect Response Data: API returns incorrect data due to logic errors.

2. Missing or Extra Fields: Response JSON or XML missing required fields or containing unexpected fields.

3. Incorrect Status Codes: API endpoints returning incorrect HTTP status codes (e.g., 200 OK for an error condition).

4. Unexpected Behavior: API does not perform operations as expected (e.g., CRUD operations not working correctly).

5. Slow Response Times: API takes too long to respond under normal or load conditions.

6. Throughput Issues: API cannot handle expected load, leading to reduced throughput.

7. Resource Utilization: High CPU, memory, or network usage during API requests.

8. Injection Attacks: Susceptibility to SQL, NoSQL, and other forms of injection attacks.

9. Cross-Site Scripting (XSS): API responses containing unescaped data leading to XSS vulnerabilities.

10. Authentication Issues: Failure to correctly implement authentication mechanisms (e.g., missing or expired tokens not handled properly).

11. Authorization Flaws: Insufficient checks allowing unauthorized access to protected resources.

26. What are the principles of an API test design?

1. Understand the API Specifications: Review the API documentation to understand the endpoints, request/response formats, parameters, authentication mechanisms, status codes, and error messages.

2. Identify Test Scenarios:

Positive Tests: Test with valid inputs to ensure the API returns the expected responses.
Negative Tests: Test with invalid inputs or boundary values to ensure the API handles errors gracefully and returns appropriate error messages.
Edge Cases: Consider unusual or extreme cases, such as very large inputs, empty inputs, or special characters.
Error Scenarios: Test the API’s behavior when it encounters errors, such as network failures, timeouts, or invalid inputs.
Logging and Monitoring: Ensure that the API has proper logging and monitoring to help diagnose and troubleshoot issues.

3. Execution: Send API requests with defined parameters, methods, and data, and observe how the system behaves.

4. Verification & Reporting: Validate the response against expected results, including status codes, response data, and schema. Document test outcomes, marking them as passed, failed, or blocked based on validation results.

5. Performance and Load Testing: Test how well the API scales under load and how it performs under peak traffic conditions.

6. Security Testing: Test that the API properly handles authentication and authorization and does not expose sensitive data.

7. Cleanup: Return the environment to its pre-test state, such as deleting test data or stopping services.

27. Can API tests run in CI/CD pipeline

Yes, API tests can and should run in a Continuous Integration/Continuous Deployment (CI/CD) pipeline to ensure the quality and reliability of your software.

Implementation Steps

1. Write and Prepare the API Tests: API Tests should be written using the suitable tools like Postman, Rest Assured, JUnit and JUnit for Java and PyTest for Python language.

2. Setup CI/CD Pipeline: CI/CD platform such as Jenkins, GitHub Actions, GitLab CI, or others can be used. example GitHub Actions workflow file to run API tests using Postman and Newman:

name: API Tests

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v2

    - name: Set up Node.js
      uses: actions/setup-node@v2
      with:
        node-version: '14'

    - name: Install Newman
      run: npm install -g newman

    - name: Run API tests with Newman
      run: newman run test.json

3. Handle Test Results: CI/CD pipeline is configured to handle and report test results. Many CI/CD tools can integrate with test reporting tools for detailed results and logs.

4. Configure Notifications or Alerts: Configure notifications (e.g., emails or Slack messages) to alert the team when tests fail. This ensures that any issues are promptly addressed.

By integrating API tests into your CI/CD pipeline, you can automatically verify the stability and reliability of your APIs with each code change.

28. What is the difference between Authentication and Authorization in API testing?

Authentication – Authentication is the process of verifying the identity of a user or system attempting to access the API. It ensures that the person or system making the API request is who they claim to be.

Example – A user logs in to a banking API using their credentials and receives a token.

Common Methods:

API Keys: A unique identifier sent with the request to validate the user or application.
Username and Password: Basic authentication.
OAuth Tokens: Access tokens issued after a successful login.
Multi-Factor Authentication (MFA): Combining two or more methods (e.g., password + OTP).
JWT (JSON Web Token): A token that securely transmits user identity

{
  "token": "eyJhbGciOiJIUzI1NiIsInR..."
}

Authorization – Authorization is the process of verifying whether an authenticated user has the necessary permissions. This process checks if they can access specific resources or perform certain actions

Example – The same user tries to transfer money to another account. The API checks if the user’s role allows this action. If the user doesn’t have sufficient permissions, the API denies the request.

Common Methods:

Role-Based Access Control (RBAC): Permissions based on user roles (e.g., Admin, User).
Policy-Based Access Control (PBAC): Custom policies to determine access rights.
Scopes in OAuth: Limit the actions that a token allows (e.g., read-only, full access).

29. Can API testing be automated? If yes, how?

Yes, API testing can be automated using tools like RestAssured, Postman, or TestNG. Test scripts can be written to send requests and validate the response. Assert the following in your tests:

1. Status Codes (e.g., 200 OK, 401 Unauthorized).
2. Response Body: Check for required fields and values.
3. Headers: Validate Content-Type, Cache-Control, etc.
4. Performance: Measure response times.

Below is an example of automated test scripts using Java with Rest Assured.

import io.restassured.http.ContentType;
import org.json.JSONObject;
import org.junit.jupiter.api.Test;
import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.equalTo;

public class APITests {

        String BaseURL = "https://reqres.in/api";

    @Test
    public void getUser() {  

        // GIVEN
        given()
                .contentType(ContentType.JSON)

                // WHEN
                .when()
                .get(BaseURL + "/users/2")

                // THEN
                .then()
                .statusCode(200)
                .body("data.first_name", equalTo("Janet"))
                .log().all();

    }

}

These tests can be run as part of CI/CD pipelines using GitLab, GitHub, Jenkins and many more.

30. What is the difference between synchronous and asynchronous APIs?

Synchronous APIs: The client waits for the server to process the request and send back a response. Request and response happen in the same thread. The client is blocked until a response is received.

Suitable for real-time, sequential tasks where the response is required immediately (e.g., login authentication). Commonly uses HTTP/HTTPS with immediate response (e.g., REST APIs).

Use Case Examples**:
  - Login authentication: The client needs the server's response before proceeding.
  - Fetching data: The client requires the result immediately to display to the user.

Asynchronous APIs: The client sends a request and continues processing without waiting for the server’s response. Request and response happen in separate threads or processes. The client continues processing while waiting for the response.

Suitable for long-running processes or tasks that do not require an immediate response (e.g., batch processing). Often uses WebSockets, Message Queues, or event-driven systems (e.g., Webhooks).

**Use Case Examples**:
  - File upload or processing: The server processes the file and sends a notification when done.
  - Notification systems: Sending push notifications to multiple devices.

June 25, 2024January 6, 2025 vibssingh

TestNG Interview Questions 2025

Last Updated On

January 6, 2025

HOME

1. What is TestNG?

TestNG is a testing framework inspired by JUnit and NUnit but introduces some new functionalities that make it more powerful and easier to use. The software testers to efficiently run the automated test scripts created in Selenium Webdriver use TestNG. Its full form is the “Testing New Generation” framework. It is used mostly to assert the results in an Automated Script as well as generate reports for test execution.

For more details, click here.

2. How TestNG can be installed in Eclipse?

Follow the below steps to install TestNG on Eclipse:

Launch Eclipse go to the Help option present at the top and select –“Install New Software”.
A dialog box will appear, click on the Add button
A new dialog box will appear. Mention the Name as TestNG and the location as “http://beust.com/eclipse/”  and click on the Add button.
Check the TestNG checkbox and click on the “Next” action button. The installation will start and the Eclipse will restart after installation.
To verify if TestNG is installed successfully or not, go to Window, select Show View, and then Other. Select Java and see within the Java folder, you will see TestNG. This shows that TestNG is successfully installed on the machine
Right-click on the project in Eclipse -> Select build path -> Configure Build Path.
Select the library tab -> Click on Add library button -> Select TestNG-> Click on Next -> Click on Finish and Apply and close.

For more details, click here

3. What is the sequence of execution of the annotations in TestNG?

The Sequence of execution of the annotations is as follows:

@BeforeSuite
@BeforeTest
@BeforeClass
@BeforeMethod
@Test
@AfterMethod
@AfterClass
@Aftertest
@AfterSuite

For more details,click here

4. What is the importance of testng.xml file?

The testng.xml file is important because of the following reasons:

It defines the order of the execution of all the test cases.
It allows you to group the test cases and can be executed as per the requirements by mentioning.

groups = { "e2etest", "integerationtest" }

3. It executes the selected test cases. It can disable the test cases that we don’t want to execute.

@Test(enabled = false)

4. In TestNG, listeners can be implemented at the suite level by adding below in xml.

listenerclass-name ="com.selenium.testng.ListenerDemo

5. It supports parallel testing means provides multiple ways to execute tests in separate threads.

suitename="TestSuite"thread-count="3"parallel="methods

6. It allows for cross-browser testing which means a web application tests on different browsers and operating systems. Here, mention different browser names in the parameter.

<parameter name="browser" value="Edge" />

7. It helps to integrate the TestNG framework in CI/CD pipelines such as GitLab, GitHub, Jenkins.

5. What are the types of Asserts in TestNG?

There are two types of assert in TestNG – Hard Assert and Soft Assert.

Hard Assert: Hard Assert is the normal assert that is used to do validations in the TestNG class.

We have to use the Assert class for hard assert as follows:

Assert.assertEquals(actual value, expected value);

If the hard assert fails, then none of the code is executed after the assert statement.

Soft Assert: If we want to continue the test execution even after the assert statement fails, then we have to use soft assert.

To create a soft assert, we have to create an object of a “softAssert” class as follows:

softAssert soft_assert = new softAssert();
soft_assert.assertAll();

So now if the test case fails, the execution does not terminate when we use soft assert.

For more details, click here.

6. What is TestNG Assert and list out some common Assertions supported by TestNG?

TestNG Asserts help us to verify the condition of the test in the middle of the test run. Based on the TestNG Assertions, we will consider a successful test only if it completed the test run without throwing any exception. Some of the common assertions supported by TestNG are:

assertEqual(String actual,String expected)
assertEqual(String actual,String expected, String message)
assertEquals(boolean actual,boolean expected)
assertTrue(condition)
assertTrue(condition, message)
assertFalse(condition)
assertFalse(condition, message)

For more details, click here

7. How to run a group of test cases using TestNG?

Groups are specified in your testng.xml file and can be found either under the <test> or <suite> tag. Groups specified in the <suite> tag apply to all the <test> tags underneath.

import org.testng.annotations.Test;
 
public class TestNGGroupDemo {
 
    @Test(alwaysRun = true, groups = { "e2etest", "integerationtest" })
    public void testPrintMessage() {
        System.out.println("This method is run by both e2e and integeration test");
    }
 
    @Test(alwaysRun = true, groups = { "e2etest" })
    public void testE2EMessage() {
        System.out.println("This method is run by e2e test");
    }
 
    @Test(alwaysRun = true, groups = { "integerationtest" })
    public void testingIntegrationMessage() {
        System.out.println("This method is run by integeration test");
    }
 
    @Test(alwaysRun = true, groups = { "acceptancetest" })
    public void testingAcceptanceMessage() {
        System.out.println("This method is run by Acceptance test");
    }
 
    @Test(alwaysRun = true, groups = { "e2etest", "acceptancetest" })
    public void testE2EAndAcceptanceMessage() {
        System.out.println("This method is run by both e2e and acceptance test");
    }
 
    @Test(alwaysRun = true, groups = { "e2etest", "integerationtest", "acceptancetest" })
    public void testE2EAndAcceptanceAndIntegrationMessage() {
        System.out.println("This method is run by e2e, integration and acceptance test");
    }
 
}

TestNG.xml

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "TestNG Demo">
    <test name = "TestNG Grouping">
        <groups>
            <run>
                <include name = "e2etest" />
            </run>
        </groups>
        <classes>
            <class name = "TestNGGroupDemo" />
        </classes>
    </test>
</suite>

The output of the above program is

For more details, click here.

8. How to set test case priority in TestNG?

We use priority attribute to the @Test annotations. If no priority is assigned to a Test Case, then the annotated test methods are, executed as per the alphabetical order of the tests

import org.testng.annotations.Test;

public class TestNGPriorityDemo {

    @Test(priority = 3)
    public static void FirstTest() {
        System.out.println("This is Test Case 1, but after priority Test Case 3");
    }


    @Test(priority = 4)
    public static void SecondTest() {
        System.out.println("This is Test Case 2, but after priority Test Case 4");
    }


    @Test(priority = 2)
    public static void ThirdTest() {
        System.out.println("This is Test Case 3, but after priority Test Case 2");
    }


    @Test(priority = 1)
    public static void FourthTest() {
        System.out.println("This is Test Case 4, but after priority Test Case 1");
    }
}

The output of the above program is

For more details, click here

9. How can we make one test method dependent on others using TestNG?

Using the dependsOnMethods parameter inside @Test annotation in TestNG we can make one test method run only after the successful execution of the dependent test method. Dependency is a feature in TestNG that allows a test method to depend on a single or a group of test methods. Method dependency only works if the “depend-on-method” is part of the same class or any of the inherited base classes (i.e. while extending a class)

         @Test
            public static void FirstTest() {
                        System.out.println("This is Test Case 1");
            }  
 
          @Test(dependsOnMethods = "FirstTest") 
             public static void SecondTest() {
                        System.out.println("This is Test Case 2 and will be executed after Test Case 1 sucessfully executed");
            } 

           @Test 
           public static void ThirdTest() {
                       System.out.println("This is Test Case 3");
             }  
 
           @Test 
             public static void FourthTest() {
                            System.out.println("This is Test Case 4"); 
         }
}

For more details, click here

10. How to skip a method or a code block in TestNG?

If you want to skip a particular test method, then you can set the ‘enabled’ parameter in the test annotation to false.

@Test(enabled = false)

By default, the value of the ‘enabled’ parameter will be true. Hence, it is not necessary to define the annotation as true while defining it.

For more details, click here

11. How do you exclude a group from the test execution cycle?

Excluding a group in TestNG denotes that this particular group refrains from running during the execution, and TestNG will ignore it. Additionally, the name of the group that we want to exclude is defined in the XML file by the following syntax:

<?xml version = "1.0"encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name = "Suite1">
   <test name = "Test Demo"> 
      <groups>
         <run>
            <exclude name = "e2etest"/>
         </run>
      </groups>
      <classes>
         <class name = "com.selenium.testng.TestNGDemo.TestNGGroupDemo"/>
      </classes>   
   </test>
</suite>

By putting our group “e2etest” inside the exclude tag, we are requesting TestNG to ignore the test cases under the group “e2etest”.

12. How to run test cases in parallel using TestNG?

In testng.xml, if we set the ‘parallel’ attribute on the tag to ‘methods’, testNG will run all the ‘@Test’ methods in the tag in a separate thread.

The parallel attribute of suite tag can accept four values:

tests – All the test cases inside tag of testng.xml file will run parallel
classes – All the test cases inside a java class will run parallel
methods – All the methods with @Test annotation will execute parallel
instances – Test cases in same instance will execute in parallel but two methods of two different instances will run in a different thread.

Below is an example to testng.xml file

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd">
<suite name="TestSuite" thread-count="3" parallel="methods" >
<test name="GoogleTest">
<classes>
<class name="TestNGDemo.ParallelTestDemo">
</class>
</classes>
</test>
</suite>

For more details,click here

13. What is the use of @Listener annotation in TestNG?

A listener is defined as an interface that modifies the default TestNG’s behavior. It allows customizing TestNG reports or logs. There are many types of TestNG listeners available. Here are a few listeners:

IAnnotationTransformer
IAnnotationTransformer2
IHookable
IInvokedMethodListener
IMethodInterceptor
IReporter
ISuiteListener
ITestListener

For more details, click here

14. How are listeners declared in TestNG?

When you implement one of these interfaces, you can let TestNG know about it in either of the following ways:

Using in your testng.xml file.

@Listeners(com.selenium.testng.TestNGDemo.ListenerDemo.class)

Using the@Listeners annotation on any of your test classes.

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "TestSuite">
<listeners>
<listener class-name ="com.selenium.testng.TestNGDemo.ListenerDemo"/>
</listeners>
 
<test name ="Test">
<classes>
<class name="com.selenium.testng.TestNGDemo.ListenerTestCases"/>
</classes>
</test>
</suite>

For more details, click here

15. Do TestNG reports need external code to write?

No, there is no need to write any code to generate reports in TestNG. In other words, the report generation happens by default.

16. What are the two reports generated in TestNG?

We can generate the TestNG reports in two ways:

· Emailable Reports
· Index Reports

17. Where is the emailable report generated and saved in TestNG?

Emailable reports are generated under the project folder and test-output subfolder. This report is available as “emailable-report.html” by default.

18. Where is the index report generate and saved in TestNG?

The index report generates under the project folder and test-output subfolder. Moreover, this report is available as “index.html” by default.

19. What is invocationCount in TestNG?

An invocationCount in TestNG is the number of times that we want to execute the same test.

import org.testng.annotations.Test;
public class InvocationCountDemo {
            @Test(invocationCount = 5)
            public void testcase1() {
                        System.out.println("testcase1");
            } 
}

Output
testcase1
testcase1
testcase1
testcase1
testcase1
PASSED: testcase1
PASSED: testcase1
PASSED: testcase1
PASSED: testcase1
PASSED: testcase1

20. How to pass the parameter in the test case through testng.xml file?

TestNG can pass different test data to a test case as arguments which is called parametrization

@Parameters("value")

TestNG.xml looks like this as shown below. Here, the parameter name is the browser name value for the browser is “Chrome”. So, this “Chrome” value is passed to Test as a parameter, and as a result a Google Chrome browser opens.

<?xml version = "1.0" encoding = "UTF-8"?>
<!DOCTYPE suite SYSTEM "http://testng.org/testng-1.0.dtd" >
<suite name = "TestSuite">
  <test name="ChromeTest">
<parameter name="browser" value="Chrome" />
<classes>
<class name="com.selenium.testng.TestNGDemo.TestNGParameterizationDemo">
</class>
</classes>
</test> 
</suite>

For more details, click here

May 22, 2024January 6, 2025 vibssingh

Advanced Selenium Interview Questions and Answers 2025

Last Updated On

January 6, 2025

HOME

1. What is a Selenium Maven project?

A Selenium Maven project is a software project that uses Maven as a build and project management tool and incorporates the Selenium WebDriver library for automated testing of web applications. Maven is a popular open-source build automation and project management tool. The pom.xml file is an important configuration file in Maven projects. It contains information about the project, its dependencies, plugins, build settings, and more. Selenium dependencies, along with other project-specific dependencies, are specified in this file.

2. What is the Selenium Grid, and how does it work?

Selenium Grid is a tool in the Selenium suite used for distributing and running tests across multiple machines (nodes) simultaneously. It allows you to execute tests in parallel, thereby reducing the overall test execution time. Selenium Grid consists of two main components: a hub and multiple nodes.

Grid can run tests (in parallel) against multiple different browsers, and it can run against multiple instances of the same browser. As an example, let’s imagine a Grid with six Nodes. The first machine has Firefox’s latest version, the second has Firefox “latest minus one”, the third gets the latest Chrome, and the remaining three machines are Mac Minis, which allows for three tests to run in parallel on the latest version of Safari.

Number of Tests * Average Test Time / Number of Nodes = Total Execution Time
 
15      *       45s        /        1        =      11m 15s   // Without Grid
15      *       45s        /        5        =      2m 15s    // Grid with 5 Nodes
15      *       45s        /        15       =      45s       // Grid with 15 Nodes

To know more about the steps to configure Selenium4, please refer to Selenium 4 Grid – Parallel Testing.

3. Is the Selenium grid suitable for performance testing?

I won’t suggest using the Selenium grid for the performance testing. Selenium Grid is primarily designed for distributed functional testing across different browsers and environments. Selenium Grid is focused on automating browser interactions and testing the functionality of web applications rather than assessing their performance.

Some popular options for performance testing include:

1. Apache JMeter: JMeter is an open-source tool widely used for load and performance testing. It allows you to simulate heavy user loads by sending HTTP requests to your application and measuring various performance metrics.

2. Gatling: Gatling is another open-source load testing tool that uses Scala as its scripting language. It provides a high-performance engine capable of generating large amounts of concurrent users while collecting detailed metrics.

3. LoadRunner: LoadRunner is a commercial tool from Micro Focus that offers a wide range of features for load and performance testing. It supports various protocols, including web-based applications, mobile apps, databases, etc., allowing you to simulate realistic user behaviour.

4. List out some of the automation tools that could be integrated with Selenium to achieve continuous testing.

1. Jenkins is an open-source automation server that supports building, deploying, and automating any project. It can be used to schedule and manage Selenium test executions, integrating with version control systems and reporting tools.

2. GitLab Pipelines is a continuous integration and continuous delivery (CI/CD) feature provided by GitLab, a web-based Git repository manager. It enables developers to automate the process of building, testing, and deploying their applications. GitLab Pipelines are defined in a file called .gitlab-ci.yml that is typically stored in the root of your repository.

3. GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform provided by GitHub.Workflows are defined using YAML files stored in a directory called .github/workflows in the GitHub repository.

4. AWS CodePipeline is a fully managed continuous integration and continuous delivery (CI/CD) service provided by Amazon Web Services (AWS). I

5. Azure Pipelines is a cloud-based continuous integration and continuous delivery (CI/CD) service provided by Microsoft Azure. Azure Pipelines supports deployment to a variety of targets, including virtual machines, container orchestration platforms like Kubernetes, and platform-as-a-service (PaaS) environments like Azure App Service.

6. Docker is a containerization platform that allows you to create, deploy, and run applications in containers. Selenium tests can be run in Docker containers to ensure consistency and reproducibility across different environments.

5. Explain the methods used to handle dynamic web elements using Selenium?

Dynamic web elements can be handled using different methods such as:-

1. Explicit Waits: Explicit waits allow you to wait for a specific condition to occur before proceeding with the next steps in your test script. This is useful when dealing with dynamic elements that may take some time to load or become interactable.

2. Implicit Waits: Implicit waits instruct Selenium to wait for a certain amount of time before throwing an exception if an element is not immediately available. While implicit waits can be helpful, they apply globally and may introduce unnecessary delays in your test scripts.

3. XPath or CSS Selectors: XPath and CSS selectors are powerful tools for locating elements on a web page based on their attributes, structure, or position relative to other elements. They provide flexibility in identifying dynamic elements even when their properties change.

6. How do you deal with stale element exceptions in Selenium?

StaleElementReferenceException is a common exception that occurs in Selenium when an element on the web page becomes stale or no longer valid. This typically happens when the DOM (Document Object Model) of the page changes, such as after a page refresh or when an element is modified dynamically.

To handle this exception, you can refresh the page, refreshing the page before attempting to interact with the element again. This helps ensure that you are working with an updated version of the DOM or try to locate the element again using a different locator strategy.

7. How can we move to the nth-child element using XPath?

We can move to the nth-child element using XPath by using the following expression:

(//parentElement/*)[n]

In the above XPath expression:
– `parentElement` represents the parent element that contains multiple child elements.
– `n` is the index number of the desired child element.

For instance, if you want to move to the 5th child element under a parent div, you would use `(//div/*)[5]`. This will select and navigate to the 5th child element under any div on the page.

8. Explain how you would perform parallel test execution using Selenium WebDriver.

1. TestNG and JUnit are popular testing frameworks that support parallel execution.

2. JUnit 5 also supports parallel execution via the @Execution(Execution.Mode.CONCURRENT) annotation.

3. Selenium Grid provides a built-in solution for parallel test execution across various browsers and devices.

4. Docker containers can be used to create isolated environments for running tests in parallel.

5. Cloud-based testing platforms like Sauce Labs, BrowserStack, or LambdaTest offer parallel execution capabilities. They provide infrastructure to run tests in parallel across various configurations (browsers, devices, operating systems) and environments.

To know more about parallel testing using TestNG, refer to How to run Parallel Tests in Selenium with TestNG.

9. Is it possible to test APIs or web services using Selenium Webdriver?

No, we cannot test APIs or web services using Selenium Webdriver as it is designed to test web-based applications.

To test APIs or web services effectively, you would typically use specialized API testing tools or libraries that are specifically designed for this purpose. Some popular tools and libraries for API testing include:

1. Postman: Postman is a comprehensive API testing tool that allows you to create and execute API requests, automate testing workflows, and perform various types of tests, including functional, performance, and security testing.

2. REST Assured: REST Assured is a powerful Java library for testing RESTful APIs. It provides a simple and expressive syntax for writing API tests and supports various authentication mechanisms, request and response validation, and more.

10. Is it possible to test the database using Selenium?

No, we cannot test the database using Selenium WebDriver as it is designed to test web-based applications. For comprehensive and thorough database testing, it’s recommended to use appropriate tools specifically designed for working with databases such as SQL clients (e.g., MySQL Workbench).

11. What is the Page Object Model in Selenium?

The Page Object Model (POM) is a design pattern used in Selenium automation testing to enhance test code maintainability, reusability, and readability. It promotes the concept of creating separate classes for each web page or component of an application being tested.

In POM, each web page or component is represented by its own class file, known as a “Page Object.” These Page Objects encapsulate the elements, actions, and behaviors associated with that specific page or component. They provide a higher-level abstraction layer that makes it easier to interact with the application under test.

For more details, click here

12. What are the different types of frameworks in Selenium?

1. Data-Driven Framework: It uses external data sources such as CSV or Excel files to drive the test execution.

2. Keyword-Driven Framework: A keyword-driven framework involves creating reusable keywords or actions that represent specific operations on the application. Test scripts are written using these keywords, making them more readable and easier to maintain. It uses specific keywords to execute test cases. A keyword-driven framework involves creating reusable keywords or actions that represent specific operations on the application under test. Test scripts are written using these keywords, making them more readable and easier to maintain.

3. Hybrid Framework: It is a combination of both Data-Driven and Keyword-Driven frameworks.

4. Page Object Model (POM) Framework: The POM framework promotes the concept of creating separate classes for each web page or component being tested. Each class represents a “Page Object” that encapsulates elements, actions, and behaviors associated with that specific page/component.

5. Behavior-Driven Development (BDD) framework: BDD frameworks like Cucumber or SpecFlow allow you to write tests in a human-readable format using Given-When-Then syntax. They promote collaboration between developers, testers, and business stakeholders by providing a common language for defining requirements and automating acceptance criteria.

13. How can you redirect browsing from a browser through some proxy?

A proxy server acts as an intermediary for requests between a client and a server. In simple terms, the traffic flows through the proxy server on its way to the address you requested and back. Selenium provides a PROXY class to redirect browsing from a proxy.

import org.openqa.selenium.Proxy;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
 
public class ProxyDemo {
 
    public static void main(String[] args) {
 
        // Set the proxy server details
        String proxyAddress = "localhost";
        int proxyPort = 8080;
 
        // Create a Proxy object and set the HTTP proxy details
        Proxy proxy = new Proxy();
        proxy.setHttpProxy(proxyAddress + ":" + proxyPort);
 
        // Configure Chrome options with the Proxy object
        ChromeOptions options = new ChromeOptions();
        options.setProxy(proxy);
        options.addArguments("start-maximized");
 
        // Instantiate ChromeDriver with the configured options
        WebDriver driver = new ChromeDriver(options);
 
 
        // Perform your browsing actions using the driver
        driver.get("https://www.google.com");
        System.out.println("Page Title :" + driver.getTitle());
 
        // Close the browser session
        driver.quit();
    }
}

14. Does Selenium has in-built reporting?

No, Selenium does not have built-in reporting capabilities. However, you can integrate Selenium with various reporting frameworks and tools to generate detailed test reports.

Some popular reporting frameworks that can be used with Selenium include:

TestNG – TestNG is a testing framework that provides built-in reporting features such as HTML reports, XML reports, and custom report generation.

ExtentReports – ExtentReports is reporting library for generating interactive and comprehensive test reports in HTML format.

Allure Framework – Allure Framework is an open-source tool that generates visually appealing and informative test reports with rich features like history trends, attachments, and categorization of tests.

Serenity Reports – If we are using Serenity for behavior-driven development (BDD), it generates detailed and interactive reports with all the necessary information in HTML format.

Cucumber Reports – If you are using Cucumber for behavior-driven development (BDD), it provides its own reporting mechanism to generate detailed reports in different formats like HTML or JSON.

15. Does Selenium support cross-browser testing?

Yes, Selenium supports cross-browser testing. Cross-browser testing is the process of executing automated tests on various web browsers to verify that a web application functions correctly and consistently across different browser environments.

WebDriver driver = new ChromeDriver(); // For Chrome

WebDriver driver = new FirefoxDriver(); // For Firefox

WebDriver driver = new EdgeDriver(); // For Edge

To know more, please refer to this – Cross Browser Testing using Selenium and TestNG.

16. How would you optimize your Selenium scripts for speed and performance?

Optimizing Selenium scripts for speed and performance is key to decreasing execution time. To optimize Selenium scripts for speed and performance, you can consider the following strategies:

1.Use headless mode – Running tests in headless mode allows the execution of browser automation without the graphical user interface (GUI), which can significantly improve performance by reducing rendering time and resource consumption.

2. Optimize data handling – When dealing with large datasets or repetitive operations, optimize data handling techniques such as reading data from external files (e.g., CSV) instead of hardcoding it within the script itself.

3. Proper use of wait – Instead of using long static wait times, leverage implicit waits or dynamic waits that wait only until a specific condition is met (e.g., element visibility or presence). This helps reduce unnecessary waiting time during script execution.

4. Parallelize test execution – If your test suite contains multiple independent tests, consider running them in parallel across multiple threads or machines using tools like TestNG or JUnit’s parallel execution features. This approach can help save time by utilizing available resources efficiently.

17. How do you handle security testing in Selenium?

1. Security testing plays a crucial role in testing an application. There are several techniques we can use for Security Testing in Selenium:

2. Cross-Site Scripting (XSS) – Cross-site scripting (XSS) is an attack in which an attacker injects malicious executable scripts into the code of a trusted application or website. Create test for XSS vulnerabilities by injecting script tags or malicious code into input fields and verifying if they get executed on the page.

3. Cross-Site Request Forgery (CSRF) – Cross-Site Request Forgery (CSRF) is an attack that forces an end user to execute unwanted actions on a web application in which they’re currently authenticated. Automate tests to verify if CSRF tokens are properly implemented and protect against unauthorized requests being made on behalf of a user.

4. Regularly update test data and configurations: Keep your test data up-to-date to reflect any changes made to how an application handles its anti-CSRF measures (e.g., updated field names, header formats).

5. Vulnerability scanning tools – Integrate vulnerability scanning tools like OWASP ZAP or Burp Suite into your Selenium tests to identify common security issues automatically.

6. Validate if sensitive information like session IDs or tokens are not exposed in URLs or stored insecurely.

7. We can make sure that the Selenium scripts are configured to work with SSL-secured websites by using the appropriate browser capabilities or options.

18. Can we integrate Selenium Framework with CI/CD pipelines? If yes, then explain.

Selenium can be integrated with CI/CD pipelines. It involves a series of steps that can help automate the testing process, ensuring that your code is always in a deployable state.

We need to create Configuration file that will define the CI/CD Pipelines

For Jenkins, this could be a Jenkinsfile.
For GitLab CI, you use .gitlab-ci.yml.
For GitHub CI, you use .maven.yml. Yml file name is not fixed here.
For CircleCI, you use .circleci/config.yml.
For Travis CI, you use .travis.yml.

Selenium tests need to be headless to be able to run in any pipeline.

May 4, 2024January 6, 2025 vibssingh

Cucumber Interview Questions and Answers 2025

Last Updated On

January 6, 2025

HOME

1. What is BDD? Why do we use BDD?

BDD (behavior-driven development ) is an Agile software development process that encourages collaboration among developers, QA, and business participants in a software project.

Why do we use BDD
BDD increases and improves collaboration between various teams involved in the project to easily engage with the product development cycle. We use a simple English language called Gherkins to write test scenarios.

2. What is Cucumber? What are the advantages of Cucumber?

Cucumber is an open-source tool that supports Behavior Driven Development (BDD). It is written in Rugby Language. Cucumber reads executable specification written in plain English language (Gherkins) and validates that the software act as per the executable specifications.

Advantages of Cucumber

Cucumber supports different languages like Java.net and Ruby.
It acts as a bridge between the business and technical language. We can accomplish this by creating a test case in plain English text.
It allows the test script to be written without knowledge of any code; it allows the involvement of non-programmers as well.
It serves the purpose of an end-to-end test framework, unlike other tools.
Due to simple test script architecture, Cucumber provides code re-usability.

Please refer to this tutorial for more details – Introduction of Cucumber Testing Tool (BDD Tool)

3. What is the programming language used by Cucumber?

The cucumber tool provides support for multiple programming languages such as Java, .Net, Ruby, etc. It can also be integrated with multiple tools such as Selenium, Capybara, etc.

Please refer to this tutorial for more details – Introduction of Cucumber Testing Tool (BDD Tool)

4. What is Gherkin?

Gherkin is a set of grammar rules that makes plain text structured enough for Cucumber to understand.

Gherkin serves multiple purposes:-

Unambiguous executable specification
Automated testing using Cucumber
Document how the system actually behaves

Please refer to this tutorial for more details – Cucumber – What is Gherkin.

5. What are the files required to execute a Cucumber test scenario?

Features
Step Definition
Test Runner

6. What is a Feature File?

A Feature File is a file in which we store features, descriptions of the features and scenarios to be tested. The first line of the feature file must start with the keyword ‘Feature’ followed by the description of the application under test. A feature file may include multiple scenarios within the same file. A feature file has the extension .feature. Below is an example of the Feature file.

Feature: Login to HRM Application 
 
   @ValidCredentials
   Scenario: Login with valid credentials
     
    Given User is on Home page
    When User enters username as "Admin"
    And User enters password as "admin123"
    Then User should be able to login sucessfully

Please refer to this tutorial for more details – Cucumber – What is Feature File in Cucumber.

7. What are the various keywords that are used in Cucumber for writing a scenario?

Below mentioned are the keywords used for writing a scenario:

Given – It is used to describe the initial context of the scenario. When the Given step is executed, it will configure the system to a well-defined state, such as creating & configuring objects or adding data to a test database.
When – It is used to describe an event or action. This can be a person interacting with the system or it can be an event triggered by another system.
Then – It is used to describe the expected outcome of the scenario
And/But – If we have several Given’s, When’s, or Then’s, then we can use And /But.

Please refer to this tutorial for more details – Cucumber – What is Feature File in Cucumber.

8. What is the purpose of the Step Definition file in Cucumber?

It is a Java method with an expression, which is used to link it to Gherkin steps. When Cucumber executes a Gherkin step, it will look for a matching step definition to execute. Step definitions can be written in many programming languages.

Feature: Book flight ticket for one-way trip
Scenario: flight ticket for one-way trip from Dublin 
Given  I live in Dublin 
  
@Given ("I live in Dublin") 
public voidVacation()
   {
        System.out.println("I live in Dublin");
   }

Please refer to this tutorial for more details – Step Definition in Cucumber

9. What is the use of the Background keyword in Cucumber?

Background keyword is used to group multiple given statements into a single group. This is generally used when the same set of given statements is repeated in each scenario in the feature file. For example, you need to pass the bearer token in every test. So, this can be done by defining the Given statement as background.

Please refer to this tutorial for more details – Background in Cucumber

10. What is the purpose of the Cucumber Options tag?

The cucumber Options tag is used to provide a link between the feature files and step definition files. Each step of the feature file is mapped to a corresponding method on the step definition file.

Below is the syntax of the Cucumber Options tag:

@CucumberOptions(features="src/test/resources/features/MyHoliday.feature",tags = { "@BookOneWayFlight"})

11. What is TestRunner class in Cucumber?

It is the starting point for JUnit to start executing the tests. TestRunner class is used to provide the link between the feature file and the step definition file.

Below is an example of TestRunner class.

import org.junit.runner.RunWith;
import io.cucumber.junit.Cucumber;
import io.cucumber.junit.CucumberOptions;
 
@RunWith(Cucumber.class)
@CucumberOptions(features = "src/test/resources/Feature/MyHoliday.feature", tags = { "@BookOneWayFlight"})
 
public classTestRunner { 
}

Please refer to this tutorial for more details – Cucumber – JUnit Test Runner Class.

12. What is a profile in cucumber?

You can create Cucumber profiles to run a set of features and step definitions. Use the following command to execute a cucumber profile.

Syntax:

cucumber features -p <profile_name>

Example:

cucumber features -p Integration

13. What are hooks in Cucumber?

Hooks are blocks of code that can run at various points in the Cucumber execution cycle

1- Before: executes before the feature file execution.
2- After: executes after the feature file execution.
3- BeforeStep: executes before each step execution.
4- AfterStep: executes after each step execution.

Below is an example of hooks.

public class CucumberHooksExampleDefinitions {
 
    WebDriver driver;
 
    @Before
    public void setup() {
 
        System.out.println("---------------------Before Executing----------------------");
        ChromeOptions chromeOptions = new ChromeOptions();
        chromeOptions.addArguments("--start-maximized");
        driver = new ChromeDriver(chromeOptions);
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
    }
 
    @BeforeStep
    public void beforeStepTest() {
        System.out.println("--------------BeforeStep Executing---------------");
    }
 
    @Given("User is on Home page")
    public void userOnHomePage() {
 
        System.out.println("Open Website");
        driver.get("https://opensource-demo.orangehrmlive.com/");
    }
 
    @When("User enters username as {string}")
    public void entersUsername(String userName) throws InterruptedException {
 
        System.out.println("Enter userName");
        driver.findElement(By.name("txtUsername")).sendKeys(userName);
 
    }
 
    @When("User enters password as {string}")
    public void entersPassword(String passWord) throws InterruptedException {
 
        System.out.println("Enter passWord");
        driver.findElement(By.name("txtPassword")).sendKeys(passWord);
 
        driver.findElement(By.id("btnLogin")).submit();
    }
 
    @Then("User should be able to login sucessfully")
    public void sucessfullLogin() throws InterruptedException {
 
        String newPageText = driver.findElement(By.id("welcome")).getText();
        System.out.println("newPageText:" + newPageText);
        assertThat(newPageText, containsString("Welcome"));
 
    }
 
    @AfterStep
    public void afterStepTest() {
        System.out.println("--------------------AfterStep Executing---------------------");
    }
 
    @After
    public void close() {
        driver.close();
        System.out.println("--------------------After Executing----------------------");
    }
}

Please refer to this tutorial for more details – Hooks in Cucumber

14. What are cucumber tags?

Tags are a great way to organize Features and Scenarios. Cucumber tags help in filtering the scenarios. We can tag the scenarios and then run them based on tags.

Below is an example of the tag.

Feature: Sample use of Tags in Cucumber
 
  @ValidCredentials
  Scenario: Login with valid credentials
    
   Given User is on Home page
   When User enters username as "Admin"
   And User enters password as "admin123"
   Then User should be able to login sucessfully

Here, @ValidCredentials is the Tag.

Please refer to this tutorial for more details – Tags in Cucumber.

15. What is the use of features property under the Cucumber Options tag?

Feature property under Cucumber option tag lets Cucumber know the location of Feature Files. As in the below example, the location of the feature file is under src/test/resources/features.

@CucumberOptions(features = "src/test/resources/Feature/MyHoliday.feature")

Please refer to this tutorial for more details – Cucumber – What is Feature File in Cucumber.

16. What is the use of glue property under the Cucumber Options tag?

The glue property lets Cucumber know the location of the Step Definition file. As in the below example, the location of the step definition is “com.cucumber.demo.definitions”.

@CucumberOptions(features = { "src/test/resources/features/MyHoliday.feature" }, glue = {"com.cucumber.demo.definitions" }

17. What is the Scenario Outline in the feature file?

Scenario outline is a way of parameterization of scenarios in Cucumber. It is used to repeat the same tests by passing different values or arguments to Step Definition. Scenario Outline must be followed by the keyword ‘Examples’, which specifies the set of values for each parameter.

Scenario Outline: Book Flight for one-way trip
   
  Given I live in Dublin with adults and kids
  And I want to book one way flight ticket from Dublin to London on 
  When I search online
  Then TripAdvisor should provide me options of flights on 
  And Cost of my flight should not be more than Euro per person
 And Tickets should be refundable
   
 Examples:
  |noOfAdults         |noOfKids         |travelDate    |flightFare    |
  |2                  |  2              |22-Jan-2020   |100           |
  |1                  |  0              |12-Mar-2020   |50            |

Please refer to this tutorial for more details – Data Driven Testing using Scenario Outline in Cucumber

18. What is the purpose of the Examples keyword in Cucumber?

Examples – All scenario outlines have to be followed by the Examples section. This contains the data that has to be passed on to the scenario in Feature File. Scenario Outline must be followed by the keyword ‘Examples’, which specifies the set of values for each parameter.

The example is shown in the previous example.

Please refer to this tutorial for more details – Data Driven Testing using Scenario Outline in Cucumber

19. Should any code be written within the TestRunner class?

No code should be written under the TestRunner class. It should include the tags @RunWith and @CucumberOptions.

20. What is the purpose of a cucumber dry-run?

We use to compile the cucumber feature files and step definitions. If there occur any compilation errors, then it shows them on the console.

@RunWith(Cucumber.class)
@CucumberOptions(dryRun=true)
public class RunCucumberTest {
}

21. List out some of the main differences between Jbehave and Cucumber?

1- Jbehave is Java-based and Cucumber is Ruby-based.
2- Jbehave is story-driven whereas the Cucumber is feature-driven.

22. What are the steps to generate a report in Cucumber?

We run the following command to produce HTML reports.

@RunWith(Cucumber.class)
@CucumberOptions(plugin = {"pretty", "html:target/cucumber"})
public class RunCucumberTest {
}

Cucumber Version 6.7.0 and above we can create a Cucumber Report by adding a cucumber.properties file in src/test/resources and mention the below instruction in it.

cucumber.publish.enabled=true

Please refer to this tutorial for more details – Cucumber Report Service

23. Does Cucumber comes with an assertion library?

No, Cucumber does not come with an assertion library. It uses assertion from unit testing tools like JUnit, TestNG, JavaScript, RSpec.

24. How to run a Cucumber test using tags in Command-Line?

mvn test -Dcucumber.filter.tags="@BookOneWayFlight"

mvn test -Dcucumber.options="@BookOneWayFlight"

Please refer to this tutorial for more details – Run Cucumber Test from Command Line.

25. Can we use Selenium with Cucumber?

Yes, we can use Selenium with Cucumber to test a Web Application. Cucumber makes the tests readable for business also. To know more about the Integration of Selenium with Cucumber, refer to this tutorial – Integration of Cucumber with Selenium and JUnit

26. What is DataTable in Cucumber?

Data Tables in Cucumber are used to add multiple parameters in Step Definition in a tabular form rather than putting all the parameters in the Gherkin statement. This is much easier to read and multiple rows of data can be passed in the same step. Data tables from Gherkin can be accessed by using the DataTable object as the last parameter in a Step Definition. Below is an example of DataTable.

Feature: Login to HRM Application 
  
   @ValidCredentials
   Scenario: Login with valid credentials
      
    Given User is on HRMLogin page
    When User enters valid credentials
    |Admin|admin123|
    Then User should be able to login sucessfully and new page open

Please refer to this tutorial for more details – DataTables in Cucumber

27. What is the difference between Scenario Outline and DataTables in Cucumber?

Scenario Outline

The Scenario Outline keyword is used to run the same Scenario multiple times, with different combinations of data.
Cucumber automatically runs the complete test the number of times equal to the number of data in the Test Set.
Example tables always have a header row, because the compiler needs to match the header columns to the placeholders in the Scenario Outline’s steps.

Scenario Outline: Book Flight for one-way trip
   
  Given I live in Dublin with adults and kids
  And I want to book one way flight ticket from Dublin to London on 
  When I search online
  Then TripAdvisor should provide me options of flights on 
  And Cost of my flight should not be more than Euro per person
 And Tickets should be refundable
   
 Examples:
  |noOfAdults         |noOfKids         |travelDate    |flightFare    |
  |2                  |  2              |22-Jan-2020   |100           |
  |1                  |  0              |12-Mar-2020   |50            |

DataTable

No keyword is used to define the test data
This works only for the single step, below which it is defined
Data tables are passed wholesale to the step definitions, and it’s up to the user to interpret them. They don’t necessarily have a header row.

Feature: Login to HRM Application 
  
   @ValidCredentials
   Scenario: Login with valid credentials
      
    Given User is on HRMLogin page
    When User enters valid credentials
    |Admin|admin123|
    Then User should be able to login sucessfully and new page open

28. Can we run Cucumber tests parallelly?

Yes, we can run Cucumber tests parallelly. Cucumber-JVM allows parallel execution across multiple threads since version 4.0.0.

Cucumber Scenarios can be executed in parallel using the JUnit Platform

Cucumber can be executed in parallel using JUnit and Maven test execution plugins.

Cucumber can be executed in parallel using TestNG and Maven test execution plugins.

Please refer to this tutorial for more details – Parallel Testing in Cucumber with TestNG.

29. Can we use Cucumber with Rest Assured?

Cucumber is not an API automation tool, but it works well with other API automation tools, like Rest Assured.

Please refer to this tutorial for more details – Rest API Test in Cucumber BDD.

This tutorial gives an idea of various questions that can be asked in an interview. Hope this helps you in the preparation of the Interview.

December 8, 2023January 6, 2025 vibssingh

CI/CD Interview Questions and Answers 2025

Last Updated On

January 6, 2025

HOME

1. What is CI/CD Pipeline?

CI/CD stands for Continuous Integration and Continuous Delivery (or Continuous Deployment), and it refers to a set of software development practices aimed at improving the efficiency, reliability, and speed of the software development and release process.

2. What’s the difference between continuous integration, continuous delivery, and continuous deployment?

Continuous Integration (CI) is a development practice wherein developers frequently merge their code modifications into a central repository. This integration occurs multiple times throughout the day and is validated through automated tests and a build procedure. This approach helps in mitigating integration issues, identifying and rectifying bugs early in the development phase, and iteratively testing and refining the code.

Continuous Delivery (CD) involves the automatic deployment of all code modifications to test and/or production environments following the completion of the build process. Continuous Delivery ensures that deployments are both predictable and consistently scheduled.

Continuous Deployment (CD): The most critical stage of the pipeline is continuous deployment. By following this practice, you will be able to release all changes that have passed all stages of the production pipeline to your customers on time. Code changes can be made live much more quickly at this stage because there is little human interaction.

3. What are the benefits of the CI/CD Pipeline?

1. CI encourages frequent integration of code changes, promoting collaboration among team members. Developers can work on their features independently, knowing that automated processes will catch integration issues.

2. CI/CD automates the software delivery process, reducing manual interventions and streamlining workflows. This results in quicker development cycles and faster releases to production.

3. Automated testing in the CI phase helps identify bugs, errors, and integration issues early in the development cycle. This allows for prompt resolution and prevents the accumulation of issues that could be more challenging to address later.

4. CI improves transparency by detecting early-stage failures like build failures, merge issues, integration test failures, etc.

5. Automation in the CI/CD pipeline reduces the need for manual steps, minimizing the risk of human error and freeing up developers and operators to focus on more strategic and creative tasks. This also increases the quality of the code.

4. What are the popular CI/CD Tools?

There are several popular CI/CD (Continuous Integration/Continuous Delivery) tools available that help automate various stages of the software development lifecycle. Here are some widely used CI/CD tools:

1. Jenkins is an open-source automation server that supports building, deploying, and automating any project. It has a large and active community, extensive plugin support, and is highly customizable.

2. Travis CI is a cloud-based CI service that integrates with GitHub repositories. It’s known for its simplicity and ease of use, and it’s commonly used for open-source projects.

3. GitLab provides built-in CI/CD capabilities as part of its platform. It allows users to define CI/CD pipelines using a .gitlab-ci.yml file in the repository. GitLab CI/CD is tightly integrated with GitLab’s version control features.

4. CircleCI is a cloud-based CI/CD platform that supports the automation of the software development process. It integrates with popular version control systems, such as GitHub and Bitbucket.

5. GitHub Actions is a CI/CD and automation service provided by GitHub. It allows developers to define workflows using YAML files within the repository. GitHub Actions seamlessly integrates with GitHub repositories.

6. Atlassian Bamboo is a CI/CD server that integrates with other Atlassian tools like Jira and Bitbucket. It supports building, testing, and deploying applications.
TeamCity:

7. TeamCity, developed by JetBrains, is a CI/CD server with support for various build and deployment scenarios. It has a user-friendly interface and integrates with popular version control systems.

8. Azure DevOps, previously known as Visual Studio Team Services (VSTS), provides a set of development tools, including CI/CD capabilities. It integrates with Microsoft’s Azure cloud services.

5. What are “Artifacts” in the context of CI/CD, and why are they important?

Artifacts are the output of a CI/CD pipeline, typically binary or deployable files such as executables, libraries, Docker images, or Reports.

1. Storing artifacts in dedicated repositories enables easy access and sharing among team members involved in the CI/CD pipeline.

2. Artifacts ensure that deployments are consistent and reproducible across different environments.

3. Artifacts provide a way to track and manage different versions of your software.

6. What are the major phases of the CI/CD pipeline?

There are four phases of the CI/CD pipeline. These are as follows.

1. Source – The first phase in a CI/CD pipeline is the creation of source code, where developers translate requirements into functional algorithms, behaviors, and features.

2. Build – The build process draws source code from a repository, establishes links to relevant libraries, modules, and dependencies, and compiles (builds) all these components into an executable (.exe) file.

3. Test – The source code has already completed some static testing, and the completed build now enters the next CI/CD phase of comprehensive dynamic testing. This usually starts with basic functional or unit testing to verify that new features and functions work as intended, and regression testing to ensure that new changes or additions do not accidentally break any previously working features.

4. Deploy – The deployment step typically involves creating a deployment environment — for example, provisioning resources and services within the data center — and moving the build to its deployment target, such as a server.

7. How do you trigger a CI/CD pipeline?

A CI/CD pipeline can be triggered in several ways. It can be activated by Code Push, scheduled trigger, manual initiation, and Continuous Integration.

8. What is version control?

Version control involves the use of a central repository where teammates can commit changes to files and sets of files. The purpose of version control is to track every line of code, and to share, review, and synchronize changes between team members. The following are some of the most popular version control tools:

Mercurial
Subversion (SVN)
Concurrent Version System (CVS)
Perforce
Bazaar
Bitkeeper
Fossil

9. What is git?

Git is a mature, actively maintained open-source revision control system used by thousands of developers around the world.
It enables developers to track changes in their source code during software development.

10. What is git repository?

A Git repository is a storage where all the code alterations and version histories for a particular project are kept. A Git repository is the .git/ folder inside a project. This repository tracks all changes made to files in your project, building a history over time. Meaning, if you delete the .git/ folder, then you delete your project’s history.

11. What is git branch?

In Git, a branch is a parallel line of development that represents an independent line of work within a Git repository. Branches let developers code without affecting the work of other team members.

12. What is merging?

Merging in Git refers to the process of integrating changes from one branch into another. When developers work on separate branches to implement features, bug fixes, or other changes, merging is used to combine those changes back into a common branch, often the main or default branch.

13. What is test coverage?

Test coverage is a metric that measures how much of the codebase is covered by tests. A 100% coverage means that every line of the code is tested at least by one test case.

14. What is the role of automation in CI/CD?

1. Automation is used to trigger and execute builds automatically whenever changes are made to the version control repository.

2. It also ensures process uniformity and lowers the possibility of human error.

3. Automation is used to set up and configure monitoring and observability tools. Automated monitoring provides insights into the health and performance of applications in real-time.

15. How to write CI/CD pipeline in Jenkins?

To write a CI/CD pipeline in Jenkins, Install Jenkins and required plugins, Set up version control such as Git, Create a Jenkins file with build, test, and deploy stages, and Save Jenkinsfile to the repository. Then, Create a Jenkins job linked to the Jenkinsfile and trigger the job for the automated CI/CD process.

16. What is a Jenkins file?

A Jenkins file is a text file that contains a pipeline’s configuration. It outlines the pipeline’s stages, such as build, test, and deployment, as well as the actions that must be taken at each one.

Example of a Jenkins File:

pipeline {
    agent any
 
    stages {
        stage('Test') {
            steps {
                bat "mvn -D clean test"
            }
 
            post {                
                // If Maven was able to run the tests, even if some of the test
                // failed, record the test results and archive the jar file.
                success {
                   publishHTML([
                       allowMissing: false, 
                       alwaysLinkToLastBuild: false, 
                       keepAll: false, 
                       reportDir: 'target/surefire-reports/', 
                       reportFiles: 'emailable-report.html', 
                       reportName: 'HTML Report', 
                       reportTitles: '', 
                       useWrapperFileDirectly: true])
                }
            }
        }
    }
}

17. What is docker?

Docker is an open platform for developing, shipping, and running applications using containers. Containers allow a developer to package up an application with all the parts it needs, such as libraries and other dependencies, and ship it all out as one package. This ensures that the application runs consistently across different environments.
A Dockerfile is a text file that contains instructions for building a Docker image. It specifies the base image, the application code, dependencies, and other configuration settings needed to create the image.

18. What is a container?

A container is a standard unit of software that packages up code and all its dependencies so the application runs quickly and reliably from one computing environment to another.

19. What is Kubernetes?

Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform designed to automate the deployment, scaling, and management of containerized applications. Kubernetes can automatically scale the number of containers based on demand. It can also distribute incoming network traffic across multiple containers to ensure optimal performance and availability.

1. Service discovery and load balancing Kubernetes can expose a container using the DNS name or using their own IP address. If traffic to a container is high, Kubernetes can load balance and distribute the network traffic so that the deployment is stable.

2. Kubernetes supports rolling updates, allowing applications to be updated with minimal downtime. If an update causes issues, Kubernetes supports easy rollbacks to a previous version.

3. Kubernetes restarts containers that fail, replaces containers, kills containers that don’t respond to your user-defined health check, and doesn’t advertise them to clients until they are ready to serve.

4. Kubernetes lets you store and manage sensitive information, such as passwords, OAuth tokens, and SSH keys. You can deploy and update secrets and application configuration without rebuilding your container images, and without exposing secrets in your stack configuration.

20. What is blue-green deployment?

Blue-green deployment is a deployment approach in which new versions of an application are deployed and tested in two identical environments, blue and green.
The old version can be called the blue environment while the new version can be known as the green environment. Once production traffic is fully transferred from blue to green, blue can standby in case of rollback or pulled from production and updated to become the template upon which the next update is made.

21. What is canary deployment?

Canary deployment is a method of application deployment in which just a small percentage of production traffic is sent to a new version of the application, with the majority of traffic still being handled by the older version. As a result, the new version can be tested and validated before being implemented across the board in the production environment.

22. What is observability?

Observability is the ability to understand and diagnose the behavior of a complex system, such as a software application, using real-time monitoring and metrics.

23. What is Grafana?

Grafana is an open-source analytics and monitoring platform that integrates with various data sources to help users visualize and understand their data. It is widely used for monitoring and observability in IT systems, providing a flexible and customizable interface for creating dashboards, charts, and graphs.
Users can create dashboards that display real-time or historical data through the use of panels and visualizations.
Grafana allows users to set up alert rules based on defined thresholds or conditions. When an alert is triggered, Grafana can send notifications via various channels, such as email, Slack, or other supported notification services.
Grafana supports user authentication and authorization. Users can be organized into teams with specific access permissions, ensuring secure access control to dashboards and data sources.

24. What is Prometheus?

Prometheus is an open-source systems monitoring and alerting toolkit originally built at SoundCloud.
Prometheus employs a pull-based model, where it regularly scrapes (pulls) metrics from endpoints exposed by the systems being monitored. This model is well-suited for dynamic and containerized environments.
Prometheus Query Language (PromQL) is a powerful query language that allows users to retrieve and analyze metrics data. It supports various aggregation functions, filtering, and mathematical operations.
Prometheus includes a built-in alerting system that allows users to define alert rules based on metric thresholds or conditions. When an alert is triggered, Prometheus can send notifications to external systems.

25. How do you ensure the security of the CI/CD pipeline?

1. To prevent unauthorized access to the pipeline and its components, access controls and authentication procedures must be put in place.

2. Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods.

3. Avoid storing sensitive information, such as API keys and credentials, directly in CI/CD configuration files or scripts. Use secure vaults or secret management tools to store and retrieve secrets securely. Ensure that secrets are not exposed in logs.

4. Implementing a safe build process that includes using trustworthy sources for dependencies and signing builds to confirm their legitimacy.

5. Regularly scan dependencies and libraries for known vulnerabilities. Utilize tools that can identify and report on security vulnerabilities in third-party dependencies. Update dependencies to patched versions to mitigate potential risk.

26. What are some challenges in implementing CI/CD?

1. Integrating CI/CD practices into existing legacy systems can be challenging.

2. Managing dependencies, especially in large projects, can be complex. Dependency management issues may arise from compatibility problems, version conflicts, or unavailability of required dependencies.

3. Security is a critical aspect of software development, and integrating security into CI/CD pipelines is a challenge. Ensuring secure coding practices, vulnerability scanning, and compliance checks requires careful consideration.

4. Integrating CI/CD pipelines with external tools, services, or platforms can be challenging. Ensuring compatibility and smooth interactions with tools like version control systems, issue trackers, and cloud services is essential.

27. Can you explain the concept of “Infrastructure as Code” (IaC) and provide an example of an IaC tool?

Infrastructure as Code (IaC) is the practice of managing and provisioning infrastructure using code and automation. Instead of manually configuring servers, networks, and other infrastructure components, IaC allows developers to define and manage their infrastructure through code. One popular example of an IaC tool is Terraform which uses a domain-specific language (HCL — HashiCorp Configuration Language) to describe infrastructure resources and their relationships. With Terraform, you can create, update, and manage infrastructure as code, making it easier to version control and maintain infrastructure configurations.

28. Is CI/CD pipeline can be targeted by attackers?

Yes, CI/CD pipeline can be targeted by the attackers. CI/CD pipelines have access to various sensor data, such as server passwords, repositories, API keys, and so on. If the CI/CD system is not properly secured, then it can be targeted by attackers. A few ways of securing the CI/CD systems are as follows.

Finding security flaws by checking code and dependencies for vulnerabilities and using static and dynamic analysis methods.

To prevent unauthorized access to the pipeline and its components, access controls and authentication procedures must be put in place.

29. What is the meaning of trunk-based development in CI/CD?

Trunk-based development is a software development approach that emphasizes frequent integration of code changes into a shared main branch, often referred to as the “trunk” or “master” branch. In the context of CI/CD, trunk-based development promotes continuous integration by encouraging developers to merge their changes into the main branch multiple times throughout the day.

30. Describe the role of container orchestration tools in CI/CD.

Container orchestration tools like Kubernetes automate the deployment, scaling, and management of containerized applications in CI/CD pipelines.

31. What is chaos engineering?

Chaos engineering is the practice of intentionally introducing failures and chaos into a system to test its resilience and reliability.

32. What is a microservices architecture?

A microservices architecture divides an application into smaller, independent services that can be developed, deployed, and scaled separately.

33. What is a canary analysis?

Canary analysis involves releasing a small subset of changes to a limited audience to assess their impact before a full deployment.

November 18, 2023January 6, 2025 vibssingh

Selenium Interview Questions and Answers 2025

Last Updated On

January 6, 2025

HOME

1. What are the different types of locators in Selenium?

Locator is the unique address of any web element on web page. Locating elements in WebDriver is done by using the method “findElement(By.locator())”.
Here, the locator() part will be replaced with locator names, like

driver.findElement(By.id("email"))

Types of Locators in Selenium

ID
ClassName
Name
TagName
LinkText
PartialLinkText
Xpath – Absolute Path & Relative Path
CSS Selector

For more details, click here.

2. What is an XPath?

XPath is used to locate a web element based on its XML path. The fundamental behind locating elements using XPath is the traversing between various elements across the entire page and thus enabling a user to find an element with the reference of another element.
Various functions used in XPath are:-
1) text()
2) contains()
3) last()
4) AND , OR
5) position()
6) following()
7) preceding()

For more details, click here

3. What is the difference between “/” and “//” in XPath?

Single Slash “/” – A single slash is used to create an XPath with an absolute path i.e. the XPath would be created to start selection from the document node/start node. For example, if we have an XML document with a root element called “form,” each form is represented by a component called “content.” The XPath expression “/form/content” would select all the immediate child elements called “content” of the “form” element. An example is given below

driver.findElement(By.xpath("/html/body/form/content"));

Double Slash “//” – Double slash is used to create an XPath with a relative path i.e. the XPath would be created to start selection from anywhere within the document. For example, the below example will select any element in the document which has an attribute named “id” with the specified value “email”.

driver.findElement(By.xpath("//*[@id = 'email']")

For more details, click here

4. How do we can launch the browser using WebDriver?

Firstly, we should instantiate a Chrome/Chromium session by doing the following

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
           
 ChromeOptions options = new ChromeOptions();
 WebDriver driver = new ChromeDriver(options);

The chromedriver is implemented as a WebDriver remote server that instructs the browser what to do by exposing Chrome’s internal automation proxy interface.

Firefox

Similarly, we can launch other browsers too like Firefox, InternetExplorer, Edge

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.Firefox.FirefoxDriver;
import org.openqa.selenium.firefox.FirefoxOptions;

         FirefoxOptions firefoxOptions = new FirefoxOptions();
        WebDriver driver = new FirefoxDriver(firefoxOptions);

MicroSoftEdge

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.edge.EdgeOptions;

      EdgeOptions options = new EdgeOptions();
      WebDriver driver = new EdgeDriver(options);

For more details, click here

5. What are the different types of Drivers available in WebDriver?

The different drivers available in WebDriver are

FirefoxDriver
InternetExplorerDriver
ChromeDriver
SafariDriver
OperaDriver
AndroidDriver
IPhoneDriver
HtmlUnitDriver

6. Explain the different exceptions in Selenium WebDriver

Exceptions in Selenium are similar to exceptions in other programming languages. The most common exceptions in Selenium are:

1. TimeoutException: This exception is thrown when a command performing an operation does not complete in the expected time.

2. NoSuchElementException: This exception is thrown when an element with given attributes is not found on the web page. Suppose webdriver is trying to click on XPath – “//*[@id=’yDmH0d’]/div/div[2]/div[2]/form/content” which doesn’t exist on that particular web page, then the below exception is displayed – org.openqa.selenium.NoSuchElementException.

3. ElementNotVisibleException: This exception is thrown when the element is present in DOM (Document Object Model), but not visible on the web page.

4. StaleElementException: This exception is thrown when the element is either deleted or no longer attached to the DOM. This exception occurs, when Selenium navigates to a different page, comes back to the same old page, and performs operations on the old page. Technically, it occurs when the element defined in the Selenium code is not found in the cache memory and the Selenium code is trying to locate it.

5. NoSuchFrameException: iframe is the HTML web page inside another HTML web page. In order to work with the Web Elements on any iframe, we have to first switch to the iframe in Selenium and then locate the respective web elements inside the iframe. NoSuchFrameException WebDriver Exception occurs when the driver in the code is unable to find the frame on the web page to switch. i.e. when the driver is switching to an invalid or non-existing iframe.

6. NoAlertPresentException: In order to work with Alert pop-ups, we have to first switch to Alert and then perform operations on Alert like reading the messages on the Alerts or Accepting the alert by pressing ‘OK’ button on the alert, etc. NoAlertPresentException WebDriver Exception occurs when the web driver is unable to find the Alert on the web page to switch. i.e. when the driver is switching to an invalid or non-existing Alert pop-up.

7. NoSuchWindowException: In order to work with the Web Elements on any Browser Pop-up Window, we have to first switch to the pop-up in Selenium and then locate the respective web elements inside the pop-up window. NoSuchWindowException WebDriver Exception occurs when the web driver is unable to find the pop-up window on the web page to switch. i.e. when the driver is switching to an invalid or non-existing pop-up window.

8. ElementNotSelectableException: This exception comes under the InvalidElementStateException class The ElementNotSelectableException indicates that the web element is present on the web page but cannot be selected.

9. SessionNotFoundException: This Exception will occur when the driver is trying to perform operations on the Web Application after the Browser is closed.

7. What are the different types of waits available in WebDriver?

How do you achieve synchronization in WebDriver?

There are three types of wait in Selenium WebDriver

1. Implicit Wait – The implicit wait will tell to the web driver to wait for a certain amount of time before it throws a “NoSuchElementException“. The default setting is 0. Once we set the time, the web driver will wait for that time before throwing an exception. Implicit waits are used to provide a default waiting time (say 30 seconds) between each consecutive test step/command across the entire test script.
We need to import java.util.concurrent.TimeUnit to use ImplicitWait.

    driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(2));

2. Explicit Wait – An explicit wait is a code you define to wait for a certain condition to occur before proceeding further in the code. The explicit wait will tell the web driver to wait for certain conditions like visibilityOfElementLocated and the maximum amount of time before throwing the NoSuchElementException exception. Unlike Implicit waits, explicit waits are applied for a particular instance only.

 Wait<WebDriver> wait = new WebDriverWait(driver, Duration.ofSeconds(2));
  wait.until(d -> revealed.isDisplayed());

3. Fluent Wait – Fluent Wait instance defines the maximum amount of time to wait for a condition, as well as the frequency with which to check the condition.

Users may configure the wait to ignore specific types of exceptions whilst waiting, such as NoSuchElementException when searching for an element on the page.

Fluent Wait commands are mainly used when the web elements which sometimes visible in a few seconds and sometimes take more time than usual. Mainly in Ajax applications. We could set the default pooling period based on the requirement.

Wait<WebDriver> wait =
        new FluentWait<>(driver)
            .withTimeout(Duration.ofSeconds(2))
            .pollingEvery(Duration.ofMillis(300))
            .ignoring(ElementNotInteractableException.class);

    wait.until(
        d -> {
          revealed.sendKeys("Displayed");
          return true;
        });

For more details, click here

8. How to set the size of the Window in Selenium WebDriver?

First, fetch the size of the browser window in pixels by the below code Dimension

//Access each dimension individually
int width = driver.manage().window().getSize().getWidth();
int height = driver.manage().window().getSize().getHeight();

//Or store the dimensions and query them later
Dimension size = driver.manage().window().getSize();
int width1 = size.getWidth();
int height1 = size.getHeight();

Now, change the size of the window by using

driver.manage().window().setSize(new Dimension(1024, 768));

9. How to set the position of Window in Selenium?

First fetch the coordinates of the top left coordinate of the browser window by

// Store the dimensions and query them later
Point position = driver.manage().window().getPosition();
         int x1 = position.getX();
         int y1 = position.getY();

// Access each dimension individually
int x = driver.manage().window().getPosition().getX();
int y = driver.manage().window().getPosition().getY();

The window can be moved to the chosen position by

// Move the window to the top left of the primary monitor
driver.manage().window().setPosition(new Point(0, 0));

10. What is the difference between driver.findElement() and driver.findElements() commands?

FindElement – This method locates the first web element on the current web page matching the criteria mentioned as the parameter.
If the web element is not found, it will throw an exception – NoSuchElementException.

driver.findElement(By.xpath("Xpath location"));

FindElements – This method locates all the web elements on the current web page matching the criteria mentioned as parameters.

If not found any WebElement on the current page as per the given element locator mechanism, it will return the empty list.

findElements (By arg0):List<WebElement

For more details, click here

11. How to type in a textbox using Selenium?

The user can use sendKeys(“String to be entered”) to enter the string in the textbox. The sendKeys type a key sequence in the DOM element even if a modifier key sequence is encountered.

Syntax - sendKeys(CharSequence… keysToSend ) : void
Command – driver.findElement(By.xpath("//*[@name = 'email']")).sendKeys("abc123@gmail.com")

For more details, click here

12. How can we get a text of a web element?

The get command is used to retrieve the inner text of the specified web element. The command doesn’t require any parameter but returns a string value. It is also one of the extensively used commands for verification of messages, labels, errors, etc displayed on the web pages.

String Text = driver.findElement(By.id(“Text”)).getText();

13. How to input text in the text box without calling the sendKeys()?

We can execute JavaScript directly to set the value of the text box.

//Creating the JavascriptExecutor interface object by Type casting                                     JavascriptExecutor js = (JavascriptExecutor)driver;              

//Launching the Site        
driver.get("https://www.google.com/");                      
js.executeScript("document.getElementsByName('q')[0].value = 'Selenium Introduction';");

The Actions class can simulate typing without sendKeys().

Actions actions = new Actions(driver);
actions.moveToElement(element).click().sendKeys("Selenium Introduction").build().perform();

For more details, click here

14. How to read a JavaScript variable in Selenium WebDriver?

You can execute JavaScript and retrieve the variable’s value using the executeScript method. This executes JavaScript in the browser context and retrieves the value of the variable.

//To initialize the JS object
JavascriptExecutor JS = (JavascriptExecutor) webdriver;

//To get the site title
String title = (String)JS.executeScript("return document.title");
System.out.println("Title of the webpage : " + title);

For more details, click here

15. What is JavaScriptExecutor and in which cases JavaScriptExecutor will help in Selenium automation?

There are some conditions where we cannot handle problems with only WebDriver. Web controls don’t react well to selenium commands. In this kind of situation, we use Javascript. It is useful for custom synchronizations, hiding or showing web elements, changing values, testing flash/HTML5, and so on.
To do these, we can use Selenium’s JavascriptExecutor interface which executes JavaScript through Selenium driver.

It provides “executescript” & “executeAsyncScript“ methods, to run JavaScript in the context of the currently selected frame or window.

JavascriptExecutor js = (JavascriptExecutor) driver; 
js.executeScript(Script,Arguments);

Script – This is the JavaScript that needs to be executed.

Arguments – It is the arguments to the script. It’s optional
Let’s see some scenarios we could handle using this Interface:
1. To type Text in Selenium WebDriver without using sendKeys() method 2. To click a Button in Selenium WebDriver using JavaScript
3. To handle Checkbox
4. To generate an Alert Pop window in Selenium
5. To refresh the browser window using Javascript
6. To get inner text of the entire webpage in Selenium
7. To get the Title of our webpage
8. To get the domain
9. To get the URL of a webpage
10. To perform Scroll on an application using Selenium

For more details, click here

16. How To Highlight Element Using Selenium WebDriver?

By using the JavascriptExecutor interface, we could highlight the specified element

//Create the JavascriptExecutor interface object by Type casting               
JavascriptExecutor js = (JavascriptExecutor)driver; 

//Higlight element - Total PageCount
WebElement TotalCount = driver.findElement(By.id("Stats1"));
js.executeScript("arguments[0].style.border='3px dotted blue'", TotalCount);

For more details, click here

17. List some scenarios that we cannot automate using Selenium WebDriver?

Bitmap comparison is not possible using Selenium WebDriver.
Automating Captcha is not possible using Selenium WebDriver.
We can not read bar code using Selenium WebDriver.
Selenium lacks built-in capabilities for image recognition or visual testing.
Selenium WebDriver is not designed for mobile app automation.
Selenium does not provide network-level control or inspection.
Selenium is not suitable for load or performance testing.
Selenium cannot interact with or verify multimedia content.
Selenium cannot handle scenarios that require advanced security testing, such as Multi-factor authentication (MFA), Token-based authentication.

18. How can you find if an element is displayed on the screen?

WebDriver facilitates the user with the following methods to check the visibility of the web elements. These web elements can be buttons, drop boxes, checkboxes, radio buttons, labels, etc.

isDisplayed()
isSelected()
isEnabled()

isDisplayed():
boolean elePresent = driver.findElement(By.xpath("xpath")).isDisplayed();

isSelected():
boolean eleSelected= driver.findElement(By.xpath("xpath")).isSelected();

isEnabled():
boolean eleEnabled= driver.findElement(By.xpath("xpath")).isEnabled();

19. Explain how you can switch back from a frame?

To switch back from a frame use the method defaultContent().

driver.switchTo().defaultContent();

20. What is the difference between getWindowhandles() and getwindowhandle() ?

getwindowhandles(): It is used to get the address of all the open browser and its return type is Set<String>

getwindowhandle(): It is used to get the address of the current browser where the control is and return type is string.

For more details, click here

21. How to select the value in a dropdown?

To perform any operation on DropDown, we need to do 2 things:-

1) Import package org.openqa.selenium.support.ui.Select
2) Create a new Select object of the class Select

Select oSelect = new Select());
Different Select Commands

1. selectByValue

Select yselect = new Select(driver.findElement(By.id("year")));
yselect.selectByValue("1988");

2. selectByVisibleText

 Select mselect = new Select(driver.findElement(By.id("month")));
 mselect.selectByVisibleText("Apr");

3. selectByIndex

Select bselect = new Select(driver.findElement(By.name("birthday_day")));
bselect.selectByIndex(8);

For more details, click here

22. How to switch to a new window (new tab) that opens up after you click on a link?

If you click on a link in a web page and it opens a new window, but WebDriver will not know which window the Operating system consider active. To change the WebDriver’s focus/ reference to the new window we need to use the switchTo() command. driver.switchTo().window();

Here, ‘windowName’ is the name of the window you want to switch your reference to.

In case you do not know the name of the window, then you can use the driver.getWindowHandle() command to get the name of all the windows that were initiated by the WebDriver. Note that it will not return the window names of browser windows which are not initiated by your WebDriver.

Once you have the name of the window, then you can use an enhanced for loop to switch to that window. Look at the piece of code below.

String handle= driver.getWindowHandle();
for (String handle : driver.getWindowHandles()) 
{
driver.switchTo().window(handle); 
}

//Store the ID of the original window
String originalWindow = driver.getWindowHandle();

//Check we don't have other windows open already
 assert driver.getWindowHandles().size() == 1;

 //Click the link which opens in a new window
 driver.findElement(By.linkText("new window")).click();

 //Wait for the new window or tab
 wait.until(numberOfWindowsToBe(2));
  
//Loop through until we find a new window handle
for (String windowHandle : driver.getWindowHandles()) {
    if(!originalWindow.contentEquals(windowHandle)) {
        driver.switchTo().window(windowHandle);
        break; 
    } 
}
  
//Wait for the new tab to finish loading content
wait.until(titleIs("Selenium documentation"));

For more details, click here

23. How to handle browser (chrome) notifications in Selenium?

In Chrome, we can use ChromeOptions as shown below.

ChromeOptions options = new ChromeOptions();
options.addArguments("disable-infobars");
WebDriver player = new ChromeDriver(options);

24. How to delete Browser Cookies with Selenium Web Driver?

To clear all cookies from the browser:

driver.Manage().Cookies.DeleteAllCookies();

To delete a specific cookie, you need to retrieve it by its name and then delete it:

driver.manage().deleteCookieNamed("cookie_name");

If you already have the cookie object, you can delete it directly:

// Get the cookie
Cookie cookie = driver.manage().getCookieNamed("cookie_name");

// Delete the specific cookie
driver.manage().deleteCookie(cookie);

25. What are the different types of navigation commands?

driver.navigate().forward(); – to navigate to the next web page with reference to the browser’s history.
driver.navigate().back(); – takes back to the previous webpage with reference to the browser’s history.
driver.navigate().refresh(); – to refresh the current web page thereby reloading all the web elements.
driver.navigate().to(“url”); – to launch a new web browser window and navigate to the specified URL.

For more details, click here

26. How can we handle Web-based Pop-ups or Alerts in Selenium?

To handle Web-based alerts or popups, we need to do switch to the alert window and call Selenium WebDriver Alert API methods.

dismiss(): To click on Cancel button.
accept(): To Click on OK button.
getText(): To get the text which is present on the Alert.
sendKeys(): To enter the text into the alert box.

For more details, click here

27. What are the ways to refresh a browser using Selenium WebDriver?

1. Using driver.navigate().refresh() command.
2. Using driver.get(“URL”) on the current URL or using driver.getCurrentUrl()
3. Using driver.navigate().to(“URL”) on the current URL or driver.navigate().to(driver.getCurrentUrl());
4. Using sendKeys(Keys.F5) on any textbox on the webpage.

28. What are the different mouse actions that can be performed?

The different mouse events supported in selenium are
1. click(WebElement element)
2. doubleClick(WebElement element)
3. contextClick(WebElement element)
4. mouseDown(WebElement element)
5. mouseUp(WebElement element)
6. mouseMove(WebElement element)
7. mouseMove(WebElement element, long xOffset, long yOffset)

For more details, click here

29. Write the code to double-click an element in selenium?

To double-click an element in Selenium, you can use the Actions class, which provides the doubleClick() method. The code to double-click an element in selenium is mentioned below

driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html");

WebElement clickable = driver.findElement(By.id("clickable"));
new Actions(driver)
.doubleClick(clickable)
.perform();

30. Write the code to right-click an element in selenium?

To right-click an element in Selenium, you can use the Actions class, which provides the contextClick() method for performing a right-click action. Below is an example:

 driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html");

WebElement clickable = driver.findElement(By.id("clickable"));
new Actions(driver)
.contextClick(clickable)
.perform();

31. How to mouse hover an element in selenium?

Code to mouse hover over an element in selenium is mentioned below:-

// Launch the URL
driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html");

WebElement hoverable = driver.findElement(By.id("hover"));
	     
new Actions(driver)
.moveToElement(hoverable)
.perform();

32. How to do drag and drop in Selenium?

Using the Action class, drag and drop can be performed in selenium.

// Launch the URL
driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html");

WebElement hoverable = driver.findElement(By.id("hover"));
	     
new Actions(driver)
.moveToElement(hoverable)
.perform();

    Or
driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html");
 
WebElement draggable = driver.findElement(By.id("draggable"));
WebElement droppable = driver.findElement(By.id("droppable"));
new Actions(driver)
.dragAndDrop(draggable, droppable)
.perform();

For more details, click here

33. How can we capture screenshots in selenium?

Using the getScreenshotAs method of the TakesScreenshot interface, we can take the screenshots in selenium.

File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(scrFile, new File("D:\\testScreenShot.jpg"));

34. Explain the difference between getText() and getAttribute() in Selenium

getAttribute() method provides the value of a particular HTML attribute and the getText() method provides the visible text of a web element. getAttribute() can be used to access attributes that are not visible on the page or to get specific information like the URL of an anchor tag (<a>).

35. Explain how to handle browser cookies in Selenium WebDriver and some different scenarios it applies to.

A HTTP cookie is comprised of information about the user and their preferences. It stores information using a key-value pair. It is a small piece of data sent from Web Application and stored in Web Browser, while the user is browsing that website.

Handling browser cookies is useful in various scenarios:

Login Sessions: Managing authentication and session cookies to simulate user login/logout scenarios. When automating Online Shopping Application, you many need to automate test scenarios like place order, View Cart, Payment Information, order confirmation, etc. If cookies are not stored, you will need to perform login action every time before you execute above listed test scenarios. This will increase your coding effort and execution time. The solution is to store cookies in a File. Later, retrieve the values of cookie from this file and add to it your current browser session. As a result, you can skip the login steps in every Test Case because your driver session has this information in it.

Remember Me Functionality: Verifying if “remember me” cookies are set and persist across sessions.

User Preferences: Storing and retrieving user-specific preferences stored in cookies.

Tracking and Analytics: Testing tracking and analytics cookies to ensure they are set correctly and track user behavior.

Consent Management: Testing cookie consent banners and verifying if cookies are set according to user consent.

Cross-Origin Resource Sharing (CORS): Handling cookies across different domains for testing cross-origin requests.

Return The List of all Cookies

Set<Cookie> cookies = driver.manage().getCookies();

Return specific cookie according to name

driver.manage().getCookieNamed(arg0);

Create and add the cookie

Cookie cookie = new Cookie("cookieName", "cookieValue");
driver.manage().addCookie(cookie);

Delete specific cookie

driver.manage().deleteCookieNamed("cookieName");

Delete all cookies

driver.manage().deleteAllCookies();

To know more, please refer to How to handle browser cookies in Selenium WebDriver.

36. What is the main disadvantage of implicit wait?

Implicit wait adds a fixed delay before each element interaction, even if the element is already available. This can significantly increase the overall test execution time, especially when there are multiple elements involved.

With implicit wait, you cannot specify different timeouts for different elements or actions on a page. It applies globally to all elements, which may not be ideal for scenarios where certain elements require shorter or longer waiting times.

If an element takes longer than expected to appear or interact with during test execution, it can be challenging to identify whether it’s due to a genuine delay or an issue with the application under test.

37. Name some of the commonly used automation testing tools that are used for non-functional automation

1. JMeter – Apache JMeter is a popular open-source tool for load testing, performance testing, and stress testing of web applications.

2. Ready API – ReadyAPI is a comprehensive suite of tools for API testing, functional testing, load testing, and security testing. It is developed by SmartBear Software and provides a unified platform to design, test, and monitor APIs throughout their lifecycle.

3. LoadRunner – LoadRunner by Micro Focus is a comprehensive performance testing tool that supports various protocols and provides in-depth analysis of system behavior under different loads.

4. Locust – Locust is an open-source load-testing framework written in Python that allows you to define user behavior using code, making it highly flexible and customizable.

5. Gatling – Gatling is another open-source load and performance testing tool that is designed to be highly scalable and efficient.

Advanced Selenium Interview Questions and Answers