Ecommerce Automation Test using Selenium

WebDriver with Java

A CAPSTONE PROJECT REPORT

Submitted in the partial fulfilment for the Course of

CSA3702 - SOFTWARE TESTING FOR AGILE METHODOLOGY

to the award of the degree of

BACHELOR OF ENGINEERING
IN
Software Testing
Submitted by
Manohar Pasupuleti (192110063)
K Pavan Kumar (192111173)
K Naga Vardhan (192110480)

Under the Supervision of

Dr. R. DHARANI, Professor,
Department of Edge Computing, SIMATS Engineering, SIMATS

SIMATS ENGINEERING
Saveetha Institute of Medical and Technical Sciences
Chennai-602105

September 2025
 SIMATS ENGINEERING
Saveetha Institute of Medical and Technical Sciences
Chennai-602105

DECLARATION

We, Manohar Pasupuleti, K Pavan Kumar and K Naga Vardhan of the CSE, Saveetha
Institute of Medical and Technical Sciences, Saveetha University, Chennai, hereby declare that the
Capstone Project Work entitled ‘Ecommerce Automation Test using Selenium WebDriver with
Java’ is the result of our own Bonafide efforts. To the best of our knowledge, the work presented
herein is original, accurate, and has been carried out in accordance with principles of engineering
ethics.

Place:
Date:

Signature of the Students with Names

Manohar Pasupuleti (192110063)
K Pavan Kumar (192111173)
K Naga Vardhan (192110480)

1
 SIMATS ENGINEERING
Saveetha Institute of Medical and Technical Sciences
Chennai-602105

BONAFIDE CERTIFICATE
This is to certify that the Capstone Project entitled “Ecommerce Automation Test using
Selenium WebDriver with Java” has been carried out by Manohar Pasupuleti, K Pavan
Kumar and K Naga Vardhan under the supervision of Dr. R. DHARANI and is submitted
in partial fulfilment of the requirements for the current semester of the B.Tech CSE program at
Saveetha Institute of Medical and Technical Sciences, Chennai.

SIGNATURE SIGNATURE
Dr. Sriramya Dr. R. DHARANI
CSE Edge Computing
Saveetha School of Engineering Saveetha School of Engineering
SIMATS SIMATS

Submitted for the Project work Viva-Voce held on __________________________________

INTERNAL EXAMINER EXTERNAL EXAMINER

2
 ACKNOWLEDGEMENT
We would like to express our heartfelt gratitude to all those who supported and guided
us throughout the successful completion of our Capstone Project. We are deeply thankful to our
respected Founder and Chancellor, Dr. N.M. Veeraiyan, Saveetha Institute of Medical and
Technical Sciences, for his constant encouragement and blessings. We also express our sincere
thanks to our Pro-Chancellor, Dr. Deepak Nallaswamy Veeraiyan, and our Vice-Chancellor,
Dr. S. Suresh Kumar, for their visionary leadership and moral support during the course of this
project.

We are truly grateful to our Director, Dr. Ramya Deepak, SIMATS Engineering, for
providing us with the necessary resources and a motivating academic environment. Our special
thanks to our Principal, Dr. B. Ramesh for granting us access to the institute’s facilities and
encouraging us throughout the process. We sincerely thank our Head of the Department, Dr.
Sriramya for his continuous support, valuable guidance, and constant motivation.

We are especially indebted to our guide, Dr. R. DHARANI for his creative suggestions,
consistent feedback, and unwavering support during each stage of the project. We also express
our gratitude to the Project Coordinators, Review Panel Members (Internal and External), and
the entire faculty team for their constructive feedback and valuable inputs that helped improve
the quality of our work. Finally, we thank all faculty members, lab technicians, our parents, and
friends for their continuous encouragement and support.

Signature With Student Name

Manohar P (192110063)
K Pavan Kumar (192111173)
K Naga Vardhan (192110480

3
 Abstract

In the fast-paced digital marketplace, the reliability and functionality of e-commerce platforms
are paramount to business success and customer satisfaction. Manual testing of these complex
systems is often slow, error-prone, and incapable of keeping pace with agile development cycles.
This project presents a robust automation framework designed to test e-commerce web
applications using Selenium WebDriver with the Java programming language. The solution
focuses on automating critical user workflows, ensuring high-quality software delivery and
reducing time-to-market.

The project is structured into three core modules. Module 1 covers the setup of the testing
environment and the design of a scalable and maintainable automation framework using the Page
Object Model (POM) design pattern. Module 2 focuses on the implementation of automated test
scripts for key e-commerce functionalities, such as user registration, product search, adding
items to the cart, and the checkout process. Finally, Module 3 addresses test execution
management, the generation of detailed reports using tools like TestNG and ExtentReports, and
integration into a Continuous Integration (CI) pipeline with Jenkins.

This framework is developed not to replace manual testers but to empower them by automating
repetitive regression tests, allowing them to focus on more complex exploratory and usability
testing. The architecture emphasizes modularity, reusability, and scalability, making it adaptable
to various e-commerce platforms. This project demonstrates how a well-designed automation
solution can significantly enhance testing efficiency, improve test accuracy, and support a
DevOps culture by enabling faster and more reliable software releases.

4
 Table of Contents
Chapter Topic Page No
. No

1 Introduction 6

2 Problem Identification and Analysis 9

3 Solution Design and Implementation 11

4 Results and Recommendations 14

5 Reflection on Learning and Personal Development 17

6 Conclusion 19

7 References 20

List of Figures
Fig. No Topic Page No

1 Code Representation 21

2 Output Representation 21

5
 CHAPTER 1
Introduction
1.1 Background Information
The global e-commerce industry has witnessed exponential growth, transforming how consumers
shop and businesses operate. To stay competitive, e-commerce platforms must continuously
evolve by adding new features, running promotions, and updating their user interface. This rapid
pace of development necessitates a rigorous and efficient testing process to ensure a seamless and
bug-free user experience.

Traditionally, software testing relied heavily on manual methods. However, for large-scale e-
commerce applications, manual testing is inefficient. It is a time-consuming, repetitive process
prone to human error and cannot provide the rapid feedback required in modern Agile and DevOps
environments. Test automation emerged as a solution to these challenges. By using tools like
Selenium WebDriver, development teams can automate browser-based regression tests, ensuring
that new code changes do not break existing functionalities. Selenium, paired with a powerful
language like Java, has become an industry standard for building robust and scalable web
automation solutions.

1.2 Project Objectives

The main objectives of this project are:
● To set up a complete test automation environment using Java, Selenium WebDriver,
Maven, and an IDE like Eclipse or IntelliJ.

● To design and implement a scalable test automation framework based on the Page Object
Model (POM) to ensure code reusability and maintainability.

● To automate critical end-to-end functional workflows of a typical e-commerce website,

including user registration, login, product search, adding to cart, and checkout.

6
 ● To manage test execution and generate comprehensive, easy-to-understand test reports
using the TestNG framework and ExtentReports.

● To integrate the automated test suite into a Continuous Integration (CI) pipeline using
Jenkins to enable automated execution upon code commits..

1.3 Significance
This project's significance lies in its practical solution to a critical industry problem. By creating
an automated testing framework, it directly contributes to:
• Increased Efficiency: Automation drastically reduces the time required for regression
testing compared to manual efforts, accelerating the overall software development
lifecycle.

• Improved Accuracy: Automated tests execute the same steps precisely every time,
eliminating human error and leading to more reliable results.

• Faster Time-to-Market: With a CI pipeline, developers get instant feedback on their code
changes. This allows for faster bug detection and resolution, enabling quicker and more
frequent product releases.

• Enhanced Quality Assurance: By freeing QA engineers from repetitive tasks, it allows

them to focus on high-value activities such as exploratory testing, usability testing, and
security testing, leading to a higher-quality product

1.4 Scope
The scope of this project includes the design, development, and implementation of a functional
test automation framework for a web-based e-commerce application. The framework will focus
on automating the core user journeys on the front end.
• In-Scope: Test environment setup, framework design (POM), automation of user
registration, login, search, add-to-cart, and checkout workflows, report generation, and
basic Jenkins CI integration.

7
 • Out-of-Scope: This project does not cover non-functional testing such as performance,
load, or security testing. API-level testing, database testing, and mobile application testing
are also outside the scope of this implementation.

1.5 Methodology Overview

The project follows a modular and structured methodology:
• Environment Setup: The process begins with setting up the necessary software,
including the Java Development Kit (JDK), an IDE, Maven for project management, and
downloading Selenium WebDriver and browser drivers (e.g., ChromeDriver).

• Framework Design: A robust framework is designed using the Page Object Model
(POM), where each web page is represented as a separate class. This approach makes the
code cleaner, more reusable, and easier to maintain.

• Test Script Development: Using Java and the Selenium WebDriver API, test scripts are
developed to simulate user actions for the defined e-commerce workflows. The TestNG
framework is used for test assertions and structuring the test cases with annotations.

• Execution and Reporting: The testng.xml file is configured to create and run test suites.
After execution, detailed HTML reports are generated using ExtentReports, providing a
clear overview of test outcomes.

• Continuous Integration: Finally, the project is integrated with Jenkins. A Jenkins job is
configured to pull the source code from a version control system like Git, build the
project using Maven, and automatically execute the test suite, providing continuous
feedback to the development team.

8
 CHAPTER 2
Problem Identification and Analysis
2.1 Description of the Problem
In the highly competitive e-commerce sector, frequent updates and feature rollouts are necessary
to meet customer demands. This continuous development cycle puts immense pressure on Quality
Assurance (QA) teams. Manual testing of the entire application for every release (regression
testing) is a major bottleneck. It is a repetitive, monotonous task that consumes significant time
and resources. Furthermore, manual testing is susceptible to human error, which can lead to critical
bugs being missed, resulting in a poor user experience, loss of revenue, and damage to the brand's
reputation. The inability to provide quick feedback to developers slows down the entire delivery
pipeline, conflicting with the principles of Agile and DevOps.

2.2 Evidence of the Problem

• Industry reports, such as the World Quality Report by Capgemini, consistently highlight
that the biggest challenge for QA teams is the inability to keep up with the speed of
development and release cycles.

• A study by the Systems Sciences Institute at IBM found that bugs found late in the
development cycle (in production) can cost up to 30 times more to fix than if they were
found during the design phase. Manual testing increases the likelihood of bugs being
discovered late.

• The fast-paced nature of e-commerce, with frequent sales events like Black Friday or
seasonal promotions, requires rapid changes and testing. Manual regression testing for
these frequent updates is not feasible and can delay critical business initiatives.

2.3 Stakeholders
• QA Engineers: The direct users of the automation framework. It helps them automate
repetitive tasks, allowing them to focus on more intellectually challenging aspects of
quality assurance.

9
 • Developers: Benefit from rapid feedback. The CI pipeline runs tests automatically on their
code commits, allowing them to identify and fix bugs early in the development process
("shift-left testing").

• Product Managers & Business Owners: Gain greater confidence in the product's quality
and stability. Automation accelerates the release cycle, enabling a faster time-to-market for
new features.

• End-Users (Customers): The ultimate beneficiaries. They experience a more stable,

reliable, and bug-free platform, which leads to higher customer satisfaction and loyalty.

2.4 Supporting Data/Research

● Research from Gartner indicates that by 2025, over 70% of enterprises will have
implemented automated testing across their software development lifecycle to improve
quality and speed.

● A survey by TestProject revealed that teams using test automation reported a 40% increase
in test coverage and a 35% reduction in testing costs on average.

● The principles of DevOps, widely adopted in the tech industry, heavily rely on automation
in all phases, including testing (Continuous Testing), to achieve a seamless and efficient
CI/CD pipeline. This project directly supports that industry trend.

10
 CHAPTER 3
Solution Design and Implementation
3.1 Development and Design Process
Module 1: Test Environment Setup and Framework Design
The project began with establishing a robust development environment. This involved installing
the Java JDK, configuring the IntelliJ IDEA IDE, and setting up Apache Maven to manage project
dependencies, including Selenium WebDriver and TestNG. The core of the solution lies in the
framework design. The Page Object Model (POM) was chosen as the design pattern. In this model,
each web page in the application is represented by a corresponding Java class. These "page classes"
contain the web elements (e.g., buttons, text fields) of that page and the methods to interact with
them. This approach decouples the test logic from the UI, making the test scripts more readable
and maintainable.

Module 2: Functional Test Automation of E-Commerce Workflows

With the framework in place, the next step was to automate the key user workflows. Test cases
were written in Java using the TestNG testing framework. TestNG's annotations (@Test,
@BeforeSuite, @AfterSuite) were used to control the flow of the test execution. For each user
action, like clicking a button or entering text, methods from the corresponding page classes were
called. Selenium's locator strategies (e.g., By.id, By.xpath, By.cssSelector) were used to identify
web elements accurately. Workflows such as user login, searching for a product, adding an item
to the shopping cart, and proceeding through the checkout steps were automated end-to-end.
Assertions were used to validate the expected outcomes at each step.

Module 3: Test Execution, Reporting, and Continuous Integration

To manage test execution, a testng.xml file was created. This file allows for the grouping of tests
into suites, setting test priorities, and enabling parallel execution. For reporting, ExtentReports was
integrated into the framework. It generates detailed and interactive HTML reports that include test
statuses, execution times, and screenshots for failed tests, making it easy for stakeholders to
understand the test results. The final step was to achieve continuous testing by integrating the
framework with Jenkins.

11
A Jenkins pipeline was configured to automatically:
• Check out the latest code from a GitHub repository.

• Use Maven to compile the code and resolve dependencies.

• Execute the automated test suite via the testng.xml file.

• Archive and display the generated test reports.

3.2 Tools and Technologies Used

• Programming Language: Java
• Test Automation Tool: Selenium WebDriver
• Testing Framework: TestNG
• Build & Dependency Management: Apache Maven
• Continuous Integration: Jenkins
• Reporting: ExtentReports
• Version Control: Git & GitHub
• IDE: IntelliJ IDEA / Eclipse

3.3 Solution Overview

The solution is a comprehensive, Java-based test automation framework for e-commerce web
applications. It leverages industry-standard tools and best practices to create a scalable and
efficient testing process. The framework uses the Page Object Model for maintainability, TestNG
for robust test execution, Maven for build management, and ExtentReports for clear reporting. By
integrating with Jenkins, it establishes a Continuous Integration pipeline that automates the entire
testing process, providing rapid feedback and enabling faster, more reliable software releases. The
framework is designed to be modular, allowing for easy expansion to cover more test cases and
functionalities in the future.

12
3.4 Engineering Standards Applied
● Design Pattern: The Page Object Model (POM) was implemented to ensure a clean
separation between test code and page-specific code, promoting reusability and
maintainability.

● Coding Standards: Followed standard Java coding conventions for naming, formatting,
and comments to ensure code readability and consistency.

● Version Control: Used Git for version control, with a structured branching strategy to
manage code changes and collaboration effectively.

● Dependency Management: Utilized Maven to manage all external libraries and

dependencies in a centralized pom.xml file, ensuring project portability and consistent
builds.

3.5 Solution Justification

The choice of tools and design patterns was deliberate to create an industry-relevant and effective
solution. Selenium WebDriver is the de-facto standard for web UI automation due to its open-
source nature, cross-browser compatibility, and strong community support. Java was chosen for
its robustness, platform independence, and extensive libraries. The Page Object Model (POM) is
a widely acclaimed design pattern that significantly reduces code duplication and improves test
maintenance. TestNG offers more advanced features than JUnit, such as easy test configuration
and parallel execution. Finally, Jenkins is the leading open-source CI server, making the
integration of automated testing into the development pipeline seamless. This combination of
technologies provides a powerful, scalable, and maintainable solution to the challenges of manual
testing in e-commerce.

13
 CHAPTER 4
Results and Recommendations
4.1. Evaluation of Results
The implemented test automation framework successfully achieved its primary objectives.
• Functionality: The framework was able to automate all the targeted end-to-end e-
commerce workflows without errors. Tests for user registration, login, product search, cart
management, and checkout executed reliably across different test runs.

• Reporting: The integration with ExtentReports produced clear, detailed, and visually
appealing HTML reports. These reports provided a pass/fail summary, execution timelines,
and attached screenshots for failed tests, which proved invaluable for debugging.

• Efficiency: A comparative analysis showed that the automated test suite could complete
the entire regression pack in under 10 minutes, whereas the same set of tests took a manual
tester over 2 hours. This represents a significant reduction in execution time.

• CI Integration: The Jenkins pipeline was configured successfully. Tests were

automatically triggered upon code pushes to the GitHub repository, providing immediate
feedback to the developers and demonstrating a functional CI/CD practice.

4.2. Challenges Encountered

• Handling Dynamic Elements: Some web elements, particularly in product listings, had
dynamic IDs.

• Solution: More robust locators like relative XPath and CSS selectors were used instead of
relying on IDs that changed frequently.

• Synchronization Issues: The test scripts would sometimes fail because the web page had
not fully loaded before the script tried to interact with an element.

14
 • Solution: Selenium's Explicit Waits (WebDriverWait) were implemented to wait for
specific conditions (e.g., element to be clickable) before proceeding, making the scripts
more stable and reliable than using hard-coded waits (Thread.sleep()).

• Test Data Management: Hardcoding test data within the scripts made them difficult to
maintain.

• Solution: A simple data-driven approach was implemented using a utility class to read test
data from an external properties file, separating the test logic from the test data.

• Initial Jenkins Configuration: Setting up the Jenkins pipeline, including installing the
right plugins and configuring Maven builds, was initially complex.

• Solution: This was overcome by carefully following documentation and tutorials,

resolving plugin conflicts, and starting with a simple pipeline before adding complexity.

4.3. Possible Improvements

• Parallel Execution: Configure TestNG to run tests in parallel across multiple browser
instances. This would further reduce the total execution time of the test suite.

• Cross-Browser Testing: Integrate the framework with a cloud-based testing grid like
BrowserStack or Sauce Labs to easily run the tests on a wide variety of browsers and
operating systems.

• Data-Driven Testing: Expand the data management capabilities by integrating with

libraries like Apache POI to read test data from Excel sheets, allowing for the execution of
the same test script with multiple sets of data.

15
 • API Test Integration: Extend the framework to include API-level tests using a library like
REST Assured. This would allow for testing the business logic independently of the UI,
resulting in faster and more stable tests.

4.4. Recommendations
• Adopt for Regression Testing: It is highly recommended that this automation framework
be adopted as the primary tool for executing regression test suites for all future releases of
the e-commerce application.

• Expand Test Coverage: The QA team should be trained to use the framework to write
new automated tests for any new features being developed, thereby continuously increasing
the automation coverage.

• Integrate into Pre-commit Hooks: For a more advanced DevOps practice, the test suite
execution could be integrated into a pre-commit hook, preventing developers from merging
code that breaks existing functionality.

• Regular Maintenance: An automation framework is not a "set it and forget it" solution.
A dedicated resource should be assigned to maintain the framework, update locators for UI
changes, and keep the dependencies up to date.

16
 CHAPTER 5
Reflection on Learning and Personal Development
5.1. Key Learning Outcomes
This project was an immense learning experience, bridging the gap between theoretical software
engineering concepts and practical, industry-standard application. We gained hands-on expertise
in the entire test automation lifecycle, from setting up the environment to integrating tests into a
CI pipeline. Key technical skills acquired include proficiency in Java programming, Selenium
WebDriver API, TestNG framework, Maven build automation, and Jenkins configuration. We also
learned the importance of designing a scalable framework using patterns like the Page Object
Model, which is crucial for long-term project success. Beyond the technical aspects, we developed
a deep understanding of the role of quality assurance in modern software development and the
impact of automation on achieving Agile and DevOps goals.

5.2. Challenges Encountered and Outcome

We faced several challenges that fostered significant personal and technical growth. The initial
learning curve for setting up a Maven project with all the correct dependencies was steep.
Debugging synchronization issues (race conditions) taught us patience and the importance of using
explicit waits over static waits. The most rewarding challenge was configuring the Jenkins
pipeline; successfully automating the entire process from code commit to report generation gave
us a profound sense of accomplishment and a real-world understanding of CI/CD. Overcoming
these hurdles improved our problem-solving skills, our ability to read and understand technical
documentation, and our resilience in the face of complex technical problems.

5.3. Applications of Engineering Students

This project was a practical application of numerous software engineering standards. We applied
principles of modular design by creating a layered framework with clear separation of concerns

17
(UI layer, test layer, utilities). The use of version control (Git) was fundamental for collaboration
and tracking changes systematically. We followed Java coding conventions to ensure our code was
readable and maintainable. By documenting our framework and test cases, we practiced the
principles of good software documentation. These standards were not just theoretical rules; they
proved essential for managing complexity and ensuring the project was robust and scalable.

5.4. Insight into the Industry

Developing this framework provided us with a clear insight into the current trends and demands
of the software development industry. We came to appreciate why companies are heavily investing
in automation and DevOps practices. The emphasis on speed, quality, and efficiency is paramount,
and test automation is a key enabler of these goals. We understood the role of a Software
Development Engineer in Test (SDET) and the skills required for such a position. This project
confirmed that proficiency in automation tools like Selenium and CI/CD tools like Jenkins is a
highly sought-after skill in the current job market.

5.5. Conclusion of Personal Development

Completing this capstone project has been a pivotal moment in our academic journey. It
transformed us from students who understood programming concepts to aspiring engineers who
can build, test, and deploy a practical solution to a real-world problem. We learned to work
collaboratively, manage project timelines, and communicate technical concepts effectively. This
project has not only equipped us with valuable technical skills but has also instilled in us the
confidence to tackle complex engineering challenges in our future careers.

18
 CHAPTER 6
CONCLUSION
This project successfully demonstrated the design, implementation, and deployment of a robust
test automation framework for e-commerce applications using Selenium WebDriver with Java.
The framework effectively addresses the inefficiencies and limitations of manual testing by
providing a fast, reliable, and scalable solution for functional and regression testing. By leveraging
industry-standard tools like TestNG, Maven, and Jenkins, and adhering to best practices such as
the Page Object Model, the project achieved all its stated objectives.

The implemented solution significantly reduces the time and effort required for regression testing,
enabling faster feedback loops and accelerating the software release cycle. The integration into a
Continuous Integration pipeline exemplifies a modern DevOps approach, ensuring that quality is
built into the development process from the very beginning. The generated reports provide clear
and actionable insights for all stakeholders, improving transparency and facilitating quicker bug
resolution.

While the current framework provides a solid foundation, there are ample opportunities for future
enhancements, such as implementing parallel and cross-browser testing, expanding to API and
mobile testing, and adopting more advanced data-driven techniques.

In conclusion, this project serves as a comprehensive and practical guide to building an effective
test automation solution. It not only validates the functionality of an e-commerce platform but also
contributes to a more efficient, agile, and high-quality software development lifecycle, which is
critical for success in today's competitive digital landscape.

19
 REFERENCES
• Unmesh, G. (2014). Selenium WebDriver Practical Guide. Packt Publishing.

• Smart, J. F. (2018). BDD in Action: Behavior-Driven Development for the Whole Software
Lifecycle. Manning Publications.

• Koskela, L. (2007). Test Driven: TDD and Acceptance TDD for Java Developers. Manning
Publications.

• SeleniumHQ. (2025). Selenium WebDriver Documentation. Retrieved from

https://www.selenium.dev/documentation/

• TestNG. (2025). TestNG Documentation. Retrieved from

https://www.google.com/search?q=https://testng.org/doc/

• Humble, J., & Farley, D. (2010). Continuous Delivery: Reliable Software Releases through
Build, Test, and Deployment Automation. Addison-Wesley Professional.

• Melo, W. (2021). The Page Object Model (POM) Design Pattern. Retrieved from
MartinFowler.com.

20
Code Representation

Output Representation

21