Name: Soham Patil

Id: TU4F2223045
Batch: A2
Roll Number: A-41

Experiment No: 9
Aim: To perform continuous testing of web applications using Selenium.
Theory:
Selenium is a powerful tool for automating web browsers. It is often used for
web application testing and to perform repetitive tasks in a browser to save
time and reduce human errors. Continuous testing is an essential part of the
software development lifecycle, ensuring that new changes or updates do not
introduce regressions or break existing functionality. Selenium can be
integrated into a continuous testing pipeline to automate the testing of web
applications at various stages of development.
Continuous testing with Selenium typically involves the following key
components and practices:
1. Automated Test Scripts: Test scripts are created using Selenium's
programming bindings (e.g., Selenium WebDriver with Java, Python,
etc.). These scripts simulate user interactions with a web application,
such as clicking buttons, filling out forms, and navigating through web
pages.
2. Version Control: Test scripts and related resources should be versioned
using a version control system (e.g., Git) to track changes and collaborate
with team members effectively.
3. Continuous Integration (CI) Server: A CI server (e.g., Jenkins, Travis CI) is
used to automate the testing process. It fetches the latest code changes,
builds the application, and runs the Selenium test scripts.
4. Headless Browsers: To speed up the testing process, headless browsers
(browsers without a graphical user interface) can be used. Headless
browsers execute test scripts faster and do not require a visible browser
window.
 5. Test Execution: The CI server executes the Selenium test scripts against
the application under test. The tests are typically run in different stages,
such as unit testing, integration testing, and end-to-end testing.
6. Reporting: Test results and logs are generated and reported by the CI
server. Any test failures or regressions are immediately reported to the
development team.
Experiment Steps:

1. Set Up Jenkins:
- Ensure that Jenkins is installed and running on your server.
2. Install Plugins:
- Install necessary Jenkins plugins, such as Git, Maven, and Selenium
WebDriver.
3. Create a New Jenkins Job:
- In Jenkins, create a new job for your Selenium tests. You can choose
between a "Freestyle project" or "Pipeline" job, but a Pipeline job is more
flexible and suitable for continuous testing.
4. Configure the Job:
- Configure your Jenkins job:
- Define the source code management (SCM) settings. Link your job to the
version control repository where your Selenium test scripts are stored (e.g.,
Git).
- Set up the build environment. Install dependencies, if necessary.
- Add build steps to execute your Selenium test scripts.
- Define post-build actions, such as archiving test results and generating
reports.
5. Scheduled or Triggered Execution:
- Decide whether you want to run your tests on a schedule or trigger them
manually:
 - For scheduled execution, use the "Build periodically" option to specify
when your tests should run (e.g., nightly or weekly).
- For triggered execution, you can manually initiate a build through the
Jenkins web interface or by using webhooks, depending on your version control
system.
6. Reports and Notifications:
- Configure Jenkins to generate test reports. Jenkins can integrate with
reporting tools like Allure or JUnit.
- Set up email notifications to alert your team about test results. Use the
"Editable Email Notification" or similar Jenkins plugins for email notifications.

7. Add Credentials (if needed):

- If your web application or Selenium scripts require authentication, configure
Jenkins to store credentials securely. Use the "Credentials" plugin for this
purpose.
8. Secure and Maintain Your Environment:
- Protect your Jenkins server and the test environment. Restrict access to
Jenkins, especially if you're running tests against sensitive applications.
- Regularly update Jenkins, plugins, and WebDriver components to ensure
your testing environment remains secure and up-to-date.
9. Run and Monitor Tests:
- Trigger your Jenkins job to execute your Selenium tests. You can monitor the
progress and view test results from the Jenkins interface.
10. Interpret and Act on Results:
- Review test results regularly. Investigate failures and regressions promptly.
Fix issues and update your tests as needed.
11. Expand and Scale Testing:
- As your application evolves, add more test cases and expand your testing
coverage.
- Optimize your test scripts and execution for better efficiency and reliability.
12. Integration with CI/CD:
- Integrate the Selenium testing process into your overall CI/CD pipeline to
automate the entire software delivery process, including testing and
deployment.
13. Documentation:
- Document the process and structure of your Selenium tests, so your team
can maintain and expand them in the future.

Conclusion: In this experiment, we learnt how to perform continuous testing of

web applications using selenium.