DEV Community: Indu Karthick kumar

Python Selenium Architecture and Significance of Python Virtual Environment

Indu Karthick kumar — Wed, 04 Jun 2025 19:02:35 +0000

Python Selenium Architecture

Selenium is a widely-used open-source tool designed for automating web browsers.

When utilizing Selenium with Python, its architecture consists of several layers and components that collaborate to automate browser activities.

Overview

Python Test Script

Written using Selenium Python Bindings.
Contains test logic: locate elements, click, send keys, assertions, etc.

Selenium WebDriver

A Python library (selenium) that provides an interface to communicate with different browser drivers.
Converts the Python commands into HTTP requests (JSON Wire Protocol was used by Selenium <= 3.x and now W3C WebDriver protocol is used by Selenium 4+).

Browser Drivers

Acts as a bridge between WebDriver and browser.
Examples: chromedriver for Chrome, geckodriver for Firefox.
Accepts WebDriver commands in JSON format over HTTP (following the W3C WebDriver standard) and communicates with the actual browser.

Browsers

Actual browsers like Chrome, Firefox, Edge, Safari.
Perform requested actions (like opening a URL, clicking a button, etc.).

Benefits of this architecture

Enables compatibility across different browsers.
Maintains test logic that is independent of programming languages (the same architecture can be used in Java, C#, etc.).
Facilitates remote execution through Selenium Grid.
Separates test scripts from the browser, enhancing flexibility

Python Virtual Environment

A Python Virtual Environment is an independent directory that includes a specific version of Python along with its associated libraries. It segregates dependencies for various projects, avoiding conflicts and ensuring that each project operates in its own distinct environment.

Advantages

Prevent conflicts among various projects
Maintain a clean and tidy system
Install and test new packages securely
This is particularly beneficial when multiple projects need different versions of the same package.

Steps to setup Python virtual environment

Step 1:

Create a virtual environment. This creates a folder "venv" with its own Python and pip libraries.

python -m venv your_project_env

Note: pip is a package management system designed for installing and managing software packages developed in Python. It enables users to effortlessly install, upgrade, and uninstall Python packages from the Python Package Index (PyPI) as well as other repositories.

Step 2:

Activate the virtual environment for Windows

your_project_env\Scripts\activate

Once the virtual environment is activated we can see the console is turned to (venv)

Step 3:

Install the required packages using

pip install package_name

This installs the given "package_name" library only inside the virtual environment, not at global level.

Step 4:

Freeze the local package environment

pip freeze > requirements.txt

This requirement.txt with a list of all installed packages and their versions. It can be used to recreate the same environment later.

Step 5:

Deactivate the Environment
To get back to the default Python environment
deactivate

Examples to understand the use of Virtual Environment better

Example 1:

To create a weather application using virtual environment

# Create a virtual environment
python -m venv weather_env

# Activate the environment
# Windows:
weather_env\Scripts\activate

# Install the requests package
pip install requests

Now the "requests" package can be used only within this project, without disturbing the global setup.

Example2:

If I want to include fun jokes to one of my project, then it can be done via virtual environment, without changing the global setup.

python -m venv add_joke
add_joke\Scripts\activate
pip install pyjokes

#importing the pyjokes inside the class
import pyjokes
print("😂 Start your day with a fun joke:", pyjokes.get_joke())

Example 3:

Consider 2 different projects need different version of requests package, then activating virtual environment for each project with the required version of requests package allows the projects to run without any conflicts.

# Project A
python -m venv projectA_env
projectA_env\Scripts\activate
pip install requests==2.25.0

deactivate

# Project B
python -m venv projectB_env
projectB_env\Scripts\activate
pip install requests==2.31.0

Example 4:

Consider if we want to test a new script using "yagmail", we can use virtual environment instead of changing the global setup.

python -m venv yagmail_env
yagmail_env\Scripts\activate
pip install yagmail

We can deactivate the venv once the testing is completed.

Summary:

Whenever we start a new Python project, always create a virtual environment first. It’s one of the best habits we can develop as a Python beginner

Selenium: Importance and Use in Web Automation with Python

Indu Karthick kumar — Fri, 30 May 2025 18:12:37 +0000

What is Selenium?

Selenium is a free and open-source tool created for automating the testing of web applications across various browsers and platforms.

It allows for the automation of user actions, including clicking buttons, entering text, navigating between pages, and selecting options from drop-down menus.

It is extensively utilized in both functional and regression testing, and it integrates seamlessly with frameworks like TestNG, JUnit, and pytest, as well as CI/CD tools like Jenkins.

With its support for parallel execution and headless testing, Selenium enhances the speed, reliability, and efficiency of testing web applications.

Selenium Components

Selenium Core: The original version created by Jason Huggins in 2004, utilizing a JavaScript-based framework. This version is now outdated due to several limitations:
It could only test web applications hosted on the same domain (same-origin policy)
Security restrictions imposed by browsers.
Selenium RC: An enhanced version of Selenium Core, which is now deprecated.
Selenium IDE: A user-friendly tool for recording and playback, ideal for beginners. However, it is not suitable for complex real-time projects.
Selenium WebDriver: The most widely used component of Selenium in real-time projects. It interacts directly with the browser using native commands, offering speed, flexibility, and support for dynamic pages.

Why use Selenium for automation?

The following benefits of Selenium encourage its use for test automation:

Selenium is an open-source tool with no licensing fees, making it accessible for both individuals and organizations.
It supports multiple programming languages, including Java, Python, C#, Ruby, and JavaScript, providing great flexibility based on the development environment or the tester's expertise.
Cross-browser testing is achievable with browsers like Chrome, Firefox, Edge, Safari, and others.
It supports cross-platform functionality, allowing tests to be executed on various operating systems such as Windows, macOS, and Linux.
It easily integrates with testing frameworks and tools such as:
TestNG / JUnit / NUnit (testing frameworks)
Maven / Gradle (build tools)
Jenkins / GitHub Actions (CI/CD)
Allure / ExtentReports (reporting)
Selenium WebDriver mimics real user interactions with the browser, which is beneficial for functional and regression testing of web applications.
Parallel test execution is facilitated through Selenium Grid, enabling tests to run simultaneously across multiple machines and browsers.
large community and robust support, learning is straightforward, with easy access to assistance, tutorials, and updates. There are numerous plugins and third-party integrations available.
Selenium enables tests to be executed without launching the browser (headless mode). This capability is perfect for CI pipelines and enhances execution speed.

Selenium automation using Python

Python is straightforward and easy to grasp, which enhances the conciseness and readability of Selenium test scripts. This is particularly beneficial for those new to automation testing.
Selenium officially supports Python, which ensures it is stable, thoroughly documented, and consistently updated.
Python facilitates rapid script development, leading to quicker creation and upkeep of test automation suites.
Selenium offers excellent integration with the Python ecosystem, including
pytest or unittest (for executing tests)
Pandas and NumPy (for managing data)
Allure and pytest-html (for generating reports)
Requests (for hybrid frameworks combining API and UI testing)
Python combined with Selenium is frequently utilized in Jenkins, GitHub Actions, GitLab CI, and similar platforms for the purpose of automated testing pipelines.

Summary:
"With Python, Selenium becomes a powerful, easy, and scalable solution for web automation testing."

Manual Testing Techniques and future of manual testing in the age of AI

Indu Karthick kumar — Fri, 14 Mar 2025 07:23:52 +0000

Common Manual Testing Techniques:
As a tester in Software development process, we need to make sure that the software product works as intended and meets high quality. In order to achieve this, we use various testing techniques like

Boundary value analysis
Equivalence partitioning
Decision table testing
State transition Testing
Use case testing
Error guessing, etc These techniques enable us to cover all possible test scenarios and identify as many defects as possible, ensuring the delivery of a high-quality application.

Boundary value analysis (BVA): Input values near the boundaries are the place where the chances of defect occurrence are high. BVA focusses on testing the boundaries of the input range. For example,
if a "Name" textbox accepts minimum 10 characters and maximum 20 characters, then in BVA values are:
Boundary values for minimum input: 9, 10, 11
Boundary value for maximum input: 19, 20, 21.

Decision Table Testing: This testing technique is used to test complex applications using combinations of inputs and the corresponding outputs.
Example: Discount on clothes based on age and membership in the store/shop
Condition1: Above 60?
Condition 2: customer has membership in the shop?
and
Action 1: 20% discount
Action 2: 10 % discount
Action 3: No discount

Age Membership 20% disc 10% disc No disc
Above 60 Yes Yes No No
Above 60 No No Yes No
Below 60 Yes No Yes No
Below 60 No No No Yes

The Future of Manual Testing in the Age of AI:
Artificial Intelligence(AI) cannot entirely replace the manual testing. Instead, it should be integrated with manual testing. AI must be trained by manual testers utilizing the application's testing history. This training enables AI to manage test scenarios independently, relying on historical data without requiring human intervention. Meanwhile, manual testing remains essential in areas that demand critical thinking, human intuition, and specialized knowledge.