RISHAV KUMAR

1. Questions générales sur le QA

a. What is software quality assurance, and why is it important?

Software Quality Assurance (SQA) is a process that ensures that software meets defined quality
standards throughout its development lifecycle. It involves activities like process monitoring, audits,
and continuous improvements to prevent defects.

⬛ Importance of SQA:

• Ensures software reliability and performance

• Reduces defects and rework, saving time and cost

• Enhances customer satisfaction

• Improves compliance with industry standards

b. What is the difference between QA, QC, and testing?

Aspect Quality Assurance (QA) Quality Control (QC) Testing

Preventive process to ensure quality Corrective process to verify the Execution of test cases to
Definition
in development processes quality of the final product identify defects

Focus Process improvement Product verification Defect identification

Timing Throughout SDLC After development is completed During testing phase

Establishing coding standards, Reviewing test results, inspecting Running functional tests
Example
process audits deliverables using Selenium

c. Can you explain the software testing life cycle (STLC)?

The Software Testing Life Cycle (STLC) is a structured approach to testing, ensuring software
quality. It consists of six phases:

1. Requirement Analysis – Understanding functional and non-functional requirements

2. Test Planning – Defining test scope, resources, schedule, and risk assessment

3. Test Case Development – Writing and reviewing test cases based on requirements

4. Test Environment Setup – Preparing hardware, software, and test data

5. Test Execution – Running test cases and reporting defects

p. 1
 RISHAV KUMAR
6. Test Closure – Preparing test summary reports, lessons learned, and final sign-off

Each phase ensures that defects are detected as early as possible.

d. What is the difference between functional and non-functional testing?

e. What is a test plan, and what does it include?

A test plan is a document that outlines the testing strategy, scope, objectives, and approach for
software testing. It helps ensure systematic and efficient testing.

⬛ A test plan typically includes:

• Test Objectives – What needs to be tested?

• Test Scope – Features to be tested and not tested

• Test Approach – Methodologies, techniques, and automation strategy
• Test Environment – Hardware, software, test data setup

• Test Schedule – Timeline and milestones

• Test Deliverables – Test cases, test scripts, test reports
• Risk Analysis – Identifying potential risks and mitigation strategies

2. Questions sur l’automatisation des tests

a. Why do we automate tests?

Test automation is used to improve efficiency, accuracy, and scalability in software testing. It helps
reduce manual effort, speeds up the testing process, and ensures consistency across multiple test
executions.

⬛ Key reasons for automating tests:

• Faster execution – Automated tests run significantly faster than manual tests.
• Better coverage – More test cases can be executed in less time.
• Repeatability – Tests can be run consistently across different environments.

p. 2
 RISHAV KUMAR

• Early bug detection – Continuous testing in CI/CD pipelines helps catch issues early.

• Cost savings in the long run – Although initial setup is costly, automation reduces long-term
testing efforts.

b. What are the advantages and disadvantages of test automation?

c. Can you explain the difference between manual and automated testing?

d. How do you decide which test cases to automate?

Not all test cases should be automated. Test automation is most effective when applied to tests that
are:

⬛ Good candidates for automation :

• Repetitive tests (e.g., regression tests)

• High-risk areas (e.g., security, payment gateway validation)

• Time-consuming manual tests

• Data-driven tests (e.g., forms with multiple inputs)

p. 3
 RISHAV KUMAR
• Cross-browser and cross-platform tests

+ Not suitable for automation :

• Exploratory and usability testing

• Tests requiring frequent UI changes
• One-time tests or ad-hoc scenarios

e. What are the key challenges in test automation?

• High initial cost & setup time – Requires investment in tools, infrastructure, and training.

• Script maintenance – Frequent application changes require continuous script updates.

• False positives/negatives – Test scripts may fail due to minor UI changes, leading to unreliable results.

• Limited testing scope – Some tests (like exploratory and usability testing) cannot be automated.

• Test data management – Creating and maintaining test data for automated tests can be complex.

• Integration with CI/CD – Ensuring smooth integration into development pipelines requires effort.

3. Questions techniques sur les outils d'automatisation

a. Which test automation tools have you worked with?

I have worked with various test automation tools depending on the type of testing required.

⬛ For UI automation:

• Selenium WebDriver – Used for web application automation.

• Cypress – Fast and reliable testing framework for modern web apps.
• Playwright – Similar to Cypress but supports multiple browsers more efficiently.

⬛ For API testing:

• Postman – Manual and automated API testing.
• RestAssured – API automation using Java.

⬛ For performance testing:

• JMeter – Load and stress testing.

• Gatling – Performance testing with Scala-based scripting.

⬛ For CI/CD integration:

• Jenkins – Automating test execution in pipelines.
• GitHub Actions/GitLab CI – Running automated tests as part of the development workflow.

p. 4
 RISHAV KUMAR

b. Can you compare Selenium and Cypress?

Conclusion:

• Use Selenium when you need cross-browser support and multiple language compatibility.
• Use Cypress when you prioritize fast, reliable execution and debugging.

c. How do you handle dynamic elements in Selenium?

Dynamic elements (e.g., elements that change IDs or appear after a delay) can be handled using:

• Explicit waits:

• XPath with contains() or starts-with():

• JavaScript Executor (for elements not detected by Selenium):

p. 5
 RISHAV KUMAR

d. What is an implicit wait vs an explicit wait in Selenium?

Type Implicit Wait Explicit Wait

Waits for a certain amount of time before

Defini Waits until a specific condition is met before
throwing an exception if an element is not
tion proceeding
found

Usage Applied globally for all elements Applied to a specific element

WebDriverWait wait = new

WebDriverWait(driver,
Exam driver.manage().timeouts().implicitlyWait(Du
Duration.ofSeconds(10));
ple ration.ofSeconds(10));
wait.until(ExpectedConditions.elementToBeC
lickable(By.id("btn")));

Flexibi
Less flexible, applies to all elements More precise, applies only where needed
lity

Best
Practi Not recommended for dynamic elements Preferred for handling specific waits
ce

Conclusion:
Use explicit waits for better control over synchronization instead of relying on implicit waits.

e. Have you worked with any CI/CD tools for test automation?

Yes, I have integrated test automation with CI/CD pipelines using different tools:

⬛ Jenkins:
• Configured jobs to run automated tests on every code commit.
• Used plugins like Allure Reports for test reporting.

⬛ GitHub Actions / GitLab CI/CD:

• Set up workflows to run Selenium and Cypress tests on cloud-based environments.

• Used Docker to create isolated test environments.

p. 6
 RISHAV KUMAR

4. Questions sur les langages de programmation et frameworks

a. Which programming languages have you used for test automation?

I have used multiple programming languages for test automation, depending on the tools and project
requirements:

⬛ Java – Used for Selenium WebDriver, TestNG, JUnit, and RestAssured for API testing.
⬛ JavaScript/TypeScript – Used with Cypress, Playwright, and WebdriverIO for modern web application
testing.

Each language has its strengths. For example, Java is widely used in enterprise automation, while
JavaScript (Cypress, Playwright) is preferred for modern front-end applications due to its speed and ease
of use.

b. Can you explain the Page Object Model (POM) and its benefits?

The Page Object Model (POM) is a design pattern used in test automation to create an abstraction
layer between test scripts and web page elements. It helps improve maintainability, readability,
and reusability of test scripts.

c. How do you handle data-driven testing?

Data-driven testing allows running the same test with multiple sets of data. It helps validate different
inputs efficiently.

⬛ Approaches for data-driven testing:

- Using TestNG DataProvider (Java Example)

p. 7
 RISHAV KUMAR
- Using Excel with Apache POI (Java Example)

Benefits of data-driven testing:

• Reduces redundancy by reusing the same test script.

• Enhances test coverage with multiple input variations.

• Saves time by automating tests with external data sources.

d. Have you written any custom test frameworks? If yes, explain the architecture.

Yes, I have worked on custom test automation frameworks based on Selenium and TestNG/Cucumber.

⬛ Custom Test Framework Architecture (Selenium + Java + TestNG)

z‘’ Structure of the framework :

Key Features of the Framework:

• Page Object Model (POM) for modularity.

• TestNG for parallel execution and reporting.

• Log4j for logging and debugging.
• Data-driven testing with Excel and JSON.
• Maven for dependency management.
p. 8
 RISHAV KUMAR

Example of BaseTest class :

e. What is BDD (Behavior-Driven Development), and how does it relate to

automation testing?

⬛ Definition:
BDD (Behavior-Driven Development) is a software development approach that focuses on
collaboration between developers, testers, and business stakeholders. It uses plain English syntax
(Gherkin) to write test cases in a Given-When-Then format.

⬛ Benefits of BDD in Test Automation:

• Improves collaboration – Business and technical teams can understand tests.

• Enhances readability – Test cases are written in natural language.

• Integrates well with Agile and CI/CD – BDD tests can be automated easily.

p. 6
 RISHAV KUMAR

5. Questions sur API Testing et performance testing

f. How do you test APIs? Which tools do you use?

API testing ensures that an API works correctly, efficiently, and securely. It involves testing
requests (GET, POST, PUT, DELETE), validating responses, handling authentication, and checking
performance.

API testing process :

1. Validation of endpoints – Ensure all API endpoints return correct responses.

2. Checking response status codes – 200 (OK), 400 (Bad Request), 401 (Unauthorized), 500
(Server Error), etc.
3. Testing request parameters – Query params, headers, body, and path variables.
4. Schema validation – Ensure the JSON/XML structure follows specifications.
5. Authentication s security testing – Validate API authentication (OAuth, JWT, Basic Auth).

6. Error handling – Check API response to invalid inputs.

7. Performance testing – Check response times under load.

g. Can you write a simple API test using Postman?

Steps to create a Postman API test:

1. Open Postman and create a new request.

2. Set request type (GET, POST, PUT, DELETE).
3. Add request URL (https://jsonplaceholder.typicode.com/posts).
4. Go to the Tests tab and write JavaScript-based assertions.

h. What is performance testing, and which tools do you use for it?

⬛ Performance testing evaluates how a system behaves under different load conditions. It helps
identify bottlenecks, scalability issues, and response times.

z‘’ Types of Performance Testing :

1. Load Testing – Measures system performance under expected load.
2. Stress Testing – Determines system behavior under extreme load conditions.

3. Spike Testing – Tests system response to sudden traffic spikes.

4. Endurance Testing – Evaluates system stability over a long period.

p. 10
 RISHAV KUMAR
z‘’ Tools for performance testing:
⬛ JMeter – Most used tool for API and web performance testing.
⬛ Gatling – Scala-based performance testing framework.
⬛ K6 – JavaScript-based load testing tool for APIs.
⬛ Locust – Python-based performance testing framework.

i. How do you analyze the results of a performance test?

⬛ Performance test results help identify system weaknesses. Key metrics include:

z‘’ 1. Response Time:

• Average response time – The average time taken for API responses.
• G5th percentile response time – Time taken by 95% of requests.

‘ 2. Throughput:
z
’

• Number of requests processed per second.

• Helps measure scalability.

z 3. Error Rate :
’
‘
• Percentage of failed requests vs. total requests.
• High error rates indicate system instability.

z‘’ 4. CPU s Memory Usage :

• Identify resource bottlenecks under high load.

⬛ Example JMeter Report Analysis:

• Throughput: 500 requests/sec

• Avg Response Time : 200ms
• Error Rate : <1% (Good)

• CPU Usage : 80% (Needs optimization)

z‘Improvement Strategies :
’
✔ Optimize API queries.
✔ Implement caching.
✔ Use load balancers.
✔ Increase server capacity.

p. 11
 RISHAV KUMAR
6. Questions sur DevOps et CI/CD
a. How do you integrate automated tests in a CI/CD pipeline?

Integrating automated tests in a CI/CD pipeline ensures that tests are executed automatically on every
code change. This helps detect issues early and maintain software quality.

Steps to integrate automated tests in CI/CD:

- Code is pushed to a repository (GitHub, GitLab, Bitbucket, etc.).

- CI/CD pipeline is triggered (Jenkins, GitHub Actions, GitLab CI, etc.).
- Build step: The application is compiled (if necessary).
- Run unit tests – Fast tests for individual components.
- Run integration and API tests – Ensure different parts of the application work together.
- Run UI tests (Selenium, Cypress, Playwright, etc.) – Check end-to-end workflows.
- Generate test reports (JUnit, Allure, HTML reports, etc.).
- Deploy to a test/staging environment if tests pass.
- Run additional performance/security tests (optional).
- Deploy to production if all tests succeed.

b. What is the role of Docker in test automation?

Docker helps create consistent and isolated environments for test execution.

- Advantages of using Docker for test automation :

- Eliminates "works on my machine" issues – Tests run in the same environment across all systems.
- Faster setup – No need to install dependencies manually.
- Parallel execution – Run tests in multiple containers for faster execution.
- CI/CD integration – Easily spin up test environments in CI/CD pipelines.
- Supports headless testing – Run UI tests in Chrome or Firefox inside containers.

c. Have you used Jenkins/GitHub Actions/GitLab CI for test automation?

Yes, I have used different CI/CD tools for test automation:

z Jenkins:
’
‘
• Used Jenkinsfile to define test execution steps.
• Integrated Selenium, Cypress, and API tests in pipelines.
• Used plugins like Allure Report for test reporting.

p. 12
 RISHAV KUMAR

’‘z GitHub Actions:

• Configured workflows to run UI and API tests on each pull request.

• Used pytest with pytest-html to generate reports.

z GitLab CI/CD:
’
‘
• Created .gitlab-ci.yml pipelines to run automated tests in different environments.
• Used Docker runners to ensure isolated test execution.

7. Questions sur les bugs et les rapports de test

a. How do you report a bug effectively?

⬛ A good bug report should be clear, concise, and reproducible. It should provide enough details for
developers to understand and fix the issue quickly.

’z‘ Steps to report a bug effectively :

Reproduce the bug – Ensure the issue is consistent.
Use a clear and descriptive title – Example : "Login button unresponsive on Chrome (v.120) after clicking
twice."
Provide detailed steps to reproduce – Step-by-step instructions to trigger the bug.
Include expected vs. actual results – Explain the correct behavior vs. the observed issue.
Attach evidence – Screenshots, logs, videos, or API responses.
Specify environment details – OS, browser version, test environment (e.g., Windows 11, Chrome 120,
Staging).
Assign priority and severity – Example: High priority, Critical severity (blocking login).

p. 13
 RISHAV KUMAR
z Example bug report format :
’
‘

b. What are the key components of a good bug report?

⬛ A well-structured bug report should contain the following key components:

‘’z 1. Title – A short, descriptive summary of the issue.

z‘’ 2. Description – A clear explanation of the bug's behavior.

z’‘ 3. Steps to Reproduce – Step-by-step instructions to trigger the issue.

z‘’ 4. Expected vs. Actual Results – Describe what should happen vs. what actually happens.

’ 5. Environment Details – OS, browser, device, test environment.

z
‘

z‘’ 6. Severity s Priority – How critical is the issue?

’ 7. Attachments (Screenshots, Logs, Videos) – Helps developers understand the issue faster.
z
‘

’ 8. Bug Status s Assignee – Current status (Open, In Progress, Resolved) and assigned developer.
z
‘

p. 14
 RISHAV KUMAR
⬛ Example of severity levels:

• Critical – System crash, data loss, or security vulnerability.

• High – Major functionality broken, no workaround.

• Medium – Functionality issue with a workaround.

• Low – Minor UI/UX issue, spelling error.

c. Can you explain a challenging bug you found and how you handled it?

Bug Description:

During testing of a web-based banking application, I discovered that after logging out, the user could
still access the previous session by clicking the "Back" button in the browser. This was a security risk
because sensitive data (account details, transactions) was still visible.

Steps Taken to Investigate:

- Reproduced the issue:

• Logged into the application.

• Performed some actions (checked account balance, viewed transactions).
• Clicked the Logout button.
• Instead of redirecting to the login page, I pressed the Back button in the browser.
• The previous session data was still visible!
- Checked network requests (DevTools → Network tab):

• Found that after logout, the browser was loading cached pages instead of redirecting to
the login page.
• No new API requests were being sent to fetch fresh data.
- Verified session storage s cookies (DevTools → Application tab):

• Session tokens and authentication cookies were cleared correctly after logout.
• However, browser cache was storing the previous session pages, allowing them to be
accessed via the Back button.
After deploying the fix, I retested the scenario and verified:
✔ After logout, pressing Back redirected to the login page.

✔ No sensitive data was accessible after logout.

p. 15