SDET interview questions

 Question: Can you describe the key components of a well-structured test automation framework?

Answer: 

Key Components of a Well-Structured Automation Framework

1. Modularity – The framework should follow a layered approach (e.g., Page Object Model for UI tests) for better maintenance.

2. Reusability – Common functions (like login, API calls, or database queries) should be written as reusable utilities.

3. Scalability – It should support adding new test cases and integrating with various tools easily.

4. Maintainability – Proper logging, reporting (e.g., Extent Reports, Allure), and exception handling should be in place.

5. Integration with CI/CD – The framework should run seamlessly in Jenkins/GitHub Actions or any other CI/CD pipeline.

 Question: How do you decide which framework to use for a project? What factors do you consider?

Answer: 

Factors for Selecting a Test Automation Framework

1. Project Requirements – UI vs. API testing, frequency of execution, and type of application.

2. Data Handling – If extensive data variations are needed, a Data-Driven approach (using Excel, JSON, or databases) is suitable.

3. Maintainability – If the application has frequent UI changes, Page Object Model (POM) helps keep locators and logic separate.

4. Parallel Execution – If speed is a concern, frameworks like TestNG (for parallel execution) or WebDriverIO with Grid can be useful.

5. Technology Stack – If the development team is using JavaScript-based tools, WebDriverIO or Cypress might be a better fit over Selenium.

6. CI/CD Integration – If seamless integration with Jenkins, GitHub Actions, or Azure DevOps is required, choosing a framework with built-in support helps.

 Question: If an API request is failing with a 500 Internal Server Error, how do you debug the issue?

Answer: A 500 error means there’s an issue on the server side, but as a tester, you can help identify the root cause.

1️⃣ Validate the API Request

• ✅ Check Request Body – Ensure JSON/XML is correctly formatted and contains required fields.

• ✅ Check Headers – Ensure Content-Type, Authorization, and other headers are correct.

• ✅ Check API Endpoint – Confirm you’re hitting the correct URL and method (GET/POST/PUT/DELETE).

2️⃣ Inspect API Response Details

• ✅ Check Response Message – Some APIs provide detailed error messages in the response body.

• ✅ Check Logs – If you have access to server logs, review them for exact error details.

3️⃣ Try Different Test Data

• ✅ Use valid and invalid payloads to see if the issue occurs with specific inputs.

• ✅ Check if the issue happens only for a specific user, role, or scenario.

4️⃣ Debug Using Tools

• ✅ Postman or ReadyAPI – Try sending the same request manually and compare responses.

• ✅ Check API Monitoring Tools – If the API is tracked in New Relic, Datadog, or Kibana, review logs for failures.

5️⃣ Collaborate with Developers

• ✅ If everything looks correct on your end, escalate with API request/response logs to the development team.

• ✅ Ask if there were recent code changes or deployments that could have caused the issue.

 Question: How would you handle API test automation failures in a CI/CD pipeline? How do you ensure tests are reliable?

Answer: 

Handling API Test Automation Failures in CI/CD

When API tests run in a Jenkins/GitHub Actions/Azure DevOps pipeline, failures can happen due to:

1. Environment Issues (e.g., API server down, incorrect base URL).

2. Data Dependencies (e.g., missing test data).

3. Network Flakiness (e.g., slow response, timeout).

4. Code Changes (e.g., API contract updates).

How to Handle Failures Effectively:

✅ 1. Retry Mechanism – If a test fails due to a timeout or network issue, retry it before marking it failed.

given()

    .when().get("/users")

    .then().statusCode(200)

    .retry(3); // Retries 3 times before failing

• In CI/CD, configure retries using a retry plugin (e.g., Jenkins Retry Plugin).

✅ 2. Use Mock Servers for Stability – Instead of always hitting a live API, use WireMock or Postman Mock Server for predictable responses.

✅ 3. Validate Response Before Assertions – If a request fails, first check if the response is valid before running assertions:

✅ 4. Parameterize Environment URLs – Use separate configs for Dev, QA, and Prod to avoid environment mismatches.

String baseUrl = System.getProperty("env", "https://dev.api.com");

 Question: If a test case is failing intermittently (flaky test), how would you debug and fix it?

Answer: A flaky test is a test that sometimes passes and sometimes fails without any code changes.

1️⃣ Manually Verify the Issue

✅ Run the test manually to check if the issue is real or caused by test script instability.
✅ If it’s a genuine bug, log a defect and escalate it to the developers.

2️⃣ Identify the Root Cause

✅ If the issue is not reproducible manually, check for these common causes:

• DOM Changes – Verify if element locators (XPath, CSS) have changed.

• Timing Issues – API calls, animations, or page loads may be slower in some cases.

• Test Data Issues – Ensure correct test data is used.

• Parallel Execution Conflicts – Tests interfering with each other in CI/CD.

3️⃣ Apply Fixes to Stabilize Tests

🔹 Use Dynamic & Stable Locators

• Avoid absolute XPath (/html/body/div[1]/table/tr[3]/td[2]).

• Prefer CSS Selectors or Relative XPath:

🔹 Implement Smart Waits

• Instead of Thread.sleep(), use Explicit Waits to handle dynamic elements:

🔹 Use Retry Mechanism

• If a test fails due to a temporary issue, retry it before marking it as failed.

🔹 Ensure Test Isolation in CI/CD

• Use unique test data to prevent conflicts.

• Run tests in separate environments or use mock servers (e.g., WireMock).

 Question: If a parallel test fails intermittently, how would you debug and fix it?

Answer: 

 Check Test Case Independence

🔹 Ensure each test runs independently without modifying shared test data.
🔹 Fix: Use unique test data for each test case:

• Generate random data dynamically (UUID.randomUUID().toString()).

• Use separate test users instead of a single user.

✅ Example: Generating Unique Test Data

2️⃣ Isolate Browser Sessions Properly

🔹 If a test modifies cookies, local storage, or session, it might affect others running in parallel.
🔹 Fix: Use incognito mode or different browser profiles.

✅ Example: Running WebDriverIO Tests in Incognito Mode

3️⃣ Use Explicit Waits for Stability

🔹 Issue: Elements take time to load, causing test failures.
🔹 Fix: Replace Thread.sleep() with Explicit Waits.

✅ Example: Wait Until Element is Clickable

4️⃣ Debug Flaky Tests with Logging & Screenshots

🔹 Enable detailed logs to track why tests fail randomly.
🔹 Fix: Capture logs and screenshots automatically on failure.

✅ Example: Capture Screenshot on Failure

5️⃣ Run Tests in Clean State

🔹 If a test modifies global state (DB, API, or UI settings), ensure it's reset.
🔹 Fix:

• Use a setup/teardown mechanism to clean data before/after each test.

• Run API calls to reset test users after execution.

✅ Example: Clean Up Data in afterEach() Hook

Final Thoughts

✅ Ensure tests don’t share data in parallel execution.
✅ Use unique browser sessions to prevent conflicts.
✅ Add logging, retries, and cleanup for stable test runs.

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

 Question: 

Answer: 

Maven Questions

Question: What is Maven and why is it used in automation project

Answer:Maven is a build automation and dependency management tool for Java-based projects. It’s used to:

• Manage project dependencies through a centralized pom.xml file.

• Compile, test, package and deploy applications.

• Integrate with CI tools like Jenkins for continuous execution.

• Ensure standard project structure and reproducibility across teams.

Question: What is pom.xml and what are its key elements?

Answer: pom.xml (Project Object Model) is the core configuration file in Maven.

Important elements:

• <dependencies> – To manage external libraries.

• <build> – Custom build steps, plugins, test execution control.

• <repositories> – Define external repo URLs (e.g., Nexus).

• <properties> – Project-level config (e.g., Java version).

• <profiles> – For managing different environments (dev, QA, prod).

Question: How do you manage dependencies in Maven?

Answer:Dependencies are declared inside the <dependencies> tag in pom.xml.

Example:

<dependency>
  <groupId>org.seleniumhq.selenium</groupId>
  <artifactId>selenium-java</artifactId>
  <version>4.19.0</version>
</dependency>

Maven downloads these automatically from the central repository or a custom one

Question: What is the difference between compile, test, provided, and runtime scopes in Maven?

Answer: 

Scope Description

compile -- Default scope, available in all classpaths.

test -- Available only during testing.

provided -- Required for compile, but not at runtime (e.g., servlet API).

runtime -- Required only during execution, not compilation.

Question: How do you execute tests using Maven?

Answer:Use the Surefire plugin to run tests:

mvn clean test

To run a specific test suite:

mvn test -DsuiteXmlFile=testng.xml

Question: How can you skip test cases in Maven?

Answer:You can skip test execution using:

mvn install -DskipTests

This compiles tests but skips running them.

To skip compilation and execution:

mvn install -Dmaven.test.skip=true

Question: What is the difference between clean, install, validate, package, and verify?

Answer:

Command Description

clean -- Deletes target/ directory.

validate -- Checks project is correct and all needed info is available.

compile -- Compiles the source code.

test -- Runs tests using testing framework.

package -- Packages compiled code into a .jar or .war.

verify -- Runs checks on test results.

install -- Installs the package to local repo (~/.m2).

Question: How do you handle version conflicts in Maven?

Answer:Use the command:

mvn dependency:tree

This shows the dependency hierarchy and highlights conflicts. Use dependency management or exclusions to resolve them:

<exclusions>

  <exclusion>

    <groupId>org.slf4j</groupId>

    <artifactId>slf4j-log4j12</artifactId>

  </exclusion>

</exclusions>

Question: What is the Surefire plugin?

Answer:Apache Surefire is a Maven plugin used for executing unit and integration tests.

<plugin>

  <groupId>org.apache.maven.plugins</groupId>

  <artifactId>maven-surefire-plugin</artifactId>

  <version>3.2.5</version>

</plugin>

Question: How do you use profiles in Maven?

Answer:Profiles are used to run Maven builds for different environments:

<profiles>

  <profile>

    <id>qa</id>

    <properties>

      <env>qa</env>

    </properties>

  </profile>

</profiles>

Activate it with:

mvn test -P qa