DEV Community: Magesh Narayanan

What is Selenium? Why do we use Selenium? What is the relevance of Selenium in automation testing using Python?

Magesh Narayanan — Tue, 08 Jul 2025 11:12:28 +0000

What is Automation Testing?
Before diving into the tools of testing we should know what Automation Testing is, Automation Testing is a software testing technique that uses automated tools and scripts to execute test cases instead of performing them manually. The main goal is to increase efficiency, coverage, and accuracy in the testing process.

Here are some automation testing tools listed below

Selenium
Winrunner
Silk Test
TestComplete
Tricentis Tosca
NUnit
Cucumber

What is Selenium?
Selenium is an open-source automated testing framework used to test and validate web application across different platforms and browsers. It allows testers to simulate user interaction with web browsers like clicking buttons, filling out forms, navigating web pages etc.
Selenium supports many programming languages, for example

Python
Java
C#
Ruby
JavaScript
R

Selenium can be integrated with test frameworks like PyTest, UnitTest and TestNG and testing tools like Jenkins, Maven, Docker, etc for CI/CD (Continuous Integration/Continuous Delivery/Deployment).

Why do we use Selenium?

We widely use Selenium because of following advantages

Browser Automation – As Selenium is designed to use in web testing it is very easy to automate tasks like form submission, login automation.
Cross browser testing – Selenium is easy to use to test in cross browsers i.e. Supports Chrome, Firefox, Safari, Edge
Language Simplicity – Works with many languages like Java, C# etc. But Python is very popular due to its simplicity.
Open Source – Selenium is OpnSource, so it is free to use with active community support.
Integration Support – Works well with tools like Jenkins, Allure, Git, etc .
Supports Parallel Testing – Using tools like Selenium Grid for distributed testing.

Relevance of Selenium in automation testing using Python

Feature Description

Feature	Description
Ease of Use	Python’s simple syntax makes writing and maintaining test scripts easier
Robust Libraries	Python has powerful libraries like unittest, pytest, and pandas for testing and data handling.
Rapid Development	Faster to develop automation scripts in Python that in other languages like Java.
Community Support	As Python is open source Community supports are received frequently. In other words Strong community and frequent updates are available for Selenium and Python.
Test Automation Frameworks	Easily integrates with frameworks like Robot framework, PyTest and Behave.

Simple Python Selenium scripts below for more understanding

from selenium import webdriver
from selenium.webdriver.common.by import By

<!--Set up the browser driver (e.g., Chrome)-->
driver = webdriver.Chrome()

<!--Open a website-->
driver.get("https://example.com")

<!--Interact with an element (click a link)-->
driver.find_element(By.LINK_TEXT, "More information...").click()

<!--Close the browser-->
driver.quit()`

Significance of Python Virtual Environment

Magesh Narayanan — Mon, 07 Jul 2025 17:48:27 +0000

A Python Virtual Environment is a self-contained directory which contains specific Python interpreter and its own set of installed packages, completely isolated from the global Python installation (system-wide).
Why Python Virtual Environment is important?

Project Isolation
Each project has its own dependencies, versions and configurations without affecting one another.
Example:-
Project A works in Django==3.2
Project B works in Django==4.0
With virtual environment both can run without any conflicts.
Avoids Global package pollution
Installing packages globally can cause
• Version conflicts
• Overwriting
• Errors in system tools or other projects
Virtual Environment avoid this by keeping packages local to the projects.
Reproducibility
You can freeze all packages used in a project into a requirements.txt file and recreate the environment anywhere.
bash CopyEdit pip freeze > requirements.txt Later... pip install -r requirements.txt
Useful in team work, deployment tc.
No Need of Admin Rights
You don’t need administrator/root permissions to install packages inside a virtual environment.
Great for restricted systems like University servers or Corporate machines.
Cleaner Development
You can easily create, activate, and delete environments without affecting anything outside your project.
How to use Virtual Environment?
Create a Virtual Environment
bash CopyEdit python -m venv myenv
Activate Virtual environment
• On windows
bash CopyEdit myenv\Scripts\activate
• On Linux/macOS
bash CopyEdit source myenv/bin/activate
Now our shell prompt will change to show (myenv)—you're working inside the environment.
Install Packages Locally
bash CopyEdit pip install requests
requests will only be available inside myenv, not system-wide.
Deactivate
bash CopyEdit Deactivate
Using Virtual Environment in PyCharm
When Creating a New Project:
Go to File > New Project
Select "New environment using venv"
PyCharm will automatically create and use that virtual environment.
For Existing Project:
File > Settings > Project > Python Interpreter
Click Add
Choose “Existing environment”
Now PyCharm will run project using the virtual environment.

Python Selenium Architecture

Magesh Narayanan — Mon, 07 Jul 2025 17:39:18 +0000

The Python Selenium architecture is the structure that enables interaction between Python programs or codes with Web browser through the Selenium Web Drivers API.
It allows automation of web-based tasks like testing, form submissions, scraping etc.

Overview of Selenium

i. Selenium is a web automation framework that allows us to programmatically control a web browser.

ii. Python bindings for Selenium let us write scripts in Python to automate browser interactions like

• Clicking buttons
• Filling forms
• Extracting information
• Navigating to pages

Architecture Components

a. Python Script:

i) Here we write our Python test cases or automation scripts or logics are written on Python.
ii) It uses Selenium Webdriver API (Python bindings) to send commands.

b. Selenium Webdrive (Client API)

• This is the core library that interacts with the browser specific driver. (ex: selenium.webdriver)
• If translates Python commands into JSON protocol or W3C webdriver protocol commands.

c. Browser Driver (like Chrome Driver, GeckoDriver)
• Acts as a bridge between Selenium and web browser.
• Receives commands from webdriver in JSON format.
• Executes those commands on the browser using the browser’s native automation support.

Example:
Chrome driver
msedgedriver
geckodriver

d. Web Browser
• The browser where the test case or automation will run.
• Executes the actions like clicking, scrolling, extracting etc.

Flow Diagram – How it works

java
Python Script
|
Selenium Webdriver (Python Bindings)
|
JSON over HTTP
Browser Driver (ex. Chrome Driver)
|
Web Browser (ex. Chrome, Firefox etc)
Example:

• We write a Python command driver.get (“https://examples.com”)
• Webdriver sends a JSON HTTP request to the browser driver
• The browser driver translates it into native browser commands
• Browser opens the URL
• Driver sends back the response to the Webdriver, which our script receives.

Python Selenium Key Classes
o webdriver.chrome() or webdriver.Firefox() Launch Browser
o driver.get (url) Navigate to page
o driver.find_element (by element_id) Find element
o element.click(), element.send_keys(“text”) Interact with element
o driver.quit() Close Browser

Supported Browsers and Drivers

Browser	Driver	Notes
Chrome	ChromeDriver	Maintained by Chromium team
Firefox	GeckoDriver	Supports modern Firefox
Edge	EdgeDriver	Supports Chromium Edge
Safari	SafariDriver	Built-in on macOS

Key Features
Supports headless execution
Can handle JavaScript-heavy websites
Can take screenshots, handle frames, alerts, and cookies.
Pytest and unittest are integrated.
Disadvantages or Limitations

Requires browser and driver compatibility
It is less efficient for data extraction compared to headless APIs like requests
It works only for web and will not work on desktop.

Installation

bash
CopyEdit
pip install selenium

Download required drivers and set it in the PATH.

Summary
Component	Description
Python Code	Logic is written
Selenium WebDriver	Python library to send commands
Browser Driver	Translator between Webdriver and Browser
Browser	Executes commands visually

╔══════════════════════╗
║ Python Test Script ║ ← we write code (e.g., login test)
╚══════════════════════╝
▼
╔══════════════════════╗
║ Selenium Python ║ ← Converts Python commands into
║ WebDriver Bindings ║ WebDriver API calls

╚══════════════════════╝
▼
╔═══════════════════════╗
║ Real Browser (Chrome) ║ ← Performs actions like clicking, typing
╚═══════════════════════╝
▼
╔═══════════════════════╗
║ Web Application (Site)║ ← Target site to test/automate/scrape
╚═══════════════════════╝

We elaborate this with an example
Consider we want to open a website and enter login credentials
Step by step Python script
from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import keys import time

Step 1: Launch Browser using chrome driver
driver = webdriver.Chrome() #Make sure the Chrome driver is in the required path

Step 2: Open a website
driver.get(“https://example.com/login”)

Step 3: Find user name and password then enter values
driver.find_element(By.ID, "username").send_keys("myuser")
driver.find_element(By.ID, "password").send_keys("mypassword")

Step 4: Submit the form
driver.find_element(By.ID, "password").send_keys(Keys.ENTER)

Step 5: Wait and close browser
time.sleep(5)
driver.quit()

Manual Testing, its future with AI

Magesh Narayanan — Thu, 01 May 2025 14:45:40 +0000

Software Testing definition?
Software testing is a systematic process for evaluating software product to identify defects and ensure whether the Software meets the required expectation.
There are various techniques to identify the defects in various stages, which are listed below with explanation:
Black Box Testing:
This technique is used to identify the defects in software functionality without looking into the code of the software. Testers use application’s interface and inputs is user defined to verify whether the software behaves as expected according to the requirement.
Example: Imagine a car’s performance in which we focus on drives, handles, feature and comfortableness without knowing the engine’s inner part’s capacity.
White Box Testing:
White box is contrast to Black Box. In Black box code will not be considered, but in white box it involves in testing internal code and structure. This testing is done by designing test cases for verify code structure, logic and behavior.
Example: Imagine a car’s performance in which we focus on engine’s inner part’s capacity and performance without knowing the design and comfortableness.
Grey Box Testing:
This is the combination of Black Box Testing and White Box Testing, testers will have some knowledge on internal structure or data this allows them to test in more targeted tests but still focusing on application’s functionalities in the user’s perspective.
Example: Imagine Task Management Application where sending the weekly update on every Friday.
Exploratory Testing:
This testing is an unstructured testing where testing is done without any predefined plan. This helps the testers to reveal unexpected issues and also identify the potential or important areas to improve from user perspective.
Example: Testing a new login page with different combination of possibilities, both success and fail cases.
Usability Testing:
This testing is done to explore user friendliness for the software. Testers interact with the application by interacting and find usability issues. Which will be helpful to improve the usability of the application?
Example: User is asked to search for available wished product using the search bar in e-commerce website. Testers are asked to test the application after the users reported difficulties in application to shop the product.
Functional Testing:
This testing includes many sub level testing techniques to verify software’s ability to perform intended requirements. Some of the types are listed below
Smoke Testing:
A quick check to confirm the software is stable and ready to undergo more extensive testing. This testing done by developers, testers will not involve in this testing phase.
This testing will be done on checking critical functionality of the software.
Example: Very common example for Smoke Testing ins Login page, where user login with correct credentials and check whether the page navigates to correct destination.

Sanity Testing:
This testing is done after a bug fix or small changes to application. Purpose of testing is to identify whether any new issues introduced which affects the progress of testing.
This testing will be done on checking area of minor functionalities. This testing will be done by testers and developers will not be involved in this testing.
This is also a sub set of regression testing.
Example: Imagine a e-commerce website where there is an issue in payment gateway, developer fixed the issue and its working fine but tester need to check whether the related area affected due to the fix.
Regression Testing:
This testing is done to verify whether any new issues are introduced due to new code change which affects existing functionality are broken.
Example: Imagine a e-commerce website which need to enhance the site by including wish list, tester will check by adding the wish list whether existing login system work fine, shopping cart and checkout remains fine and accurate.
Re-testing:
This testing is done to verify whether reported bugs are fixed and also verifying whether the fixed bugs cause any other introduced issues.
Example: Let’s take save as button, while testing first it’s not working and issue is reported to developer and it was fixed. Tester again tests the same functionality and confirms its working as expected.
Acceptance Testing:
This testing is done before the final release of the application, to confirm whether the application meets the required requirement and user expectation of the application.
Non-functional Testing:
Non-functional testing check the non-functional attributes of any software like performance, usability, reliability, security, visual testing.
Performance Testing:
Testing involves testing Load, Stress, and spike which ensures software resilience.
Load Testing:
Testing done to identify the system’s behavior under both normal and peak load conditions. For example we take result publishing.
Example: Results will be published all over the division the browser should not hang, crash the system or browser.
Considering another example is OTT, where users are streaming the same content in same time which ensures smooth playback and prevent buffering.
Stress Testing:
Stress Testing is performed to verify whether the system, application performs under the extreme or abnormal conditions. This stress testing is not designed to handle nor scenario but to hands beyond the limits or capacity of application or website.
Example: Simulating a website’s ability to handle the raise of traffic during publishing of results which pushes beyond its normal limits which uses to find the failure points and bottlenecks of the website.
Boundary Value Analysis
Boundary Value Analysis is testing two values for each boundary, i.e. testing the boundary and adjacent of boundary. This testing is performed to verify the potential errors that may occur near boundaries.
Decision Table Testing
Decision table testing is useful for systems with complex business rules where different combinations of input result in different outcomes.
Below is the Decision Table
Stubs Entries
Conditionc1
c2
c3

Action a1
a2
a3
a4

Condition Stubs: Conditions are listed below the Stubs (c1, c2, c3) which are used to determine a particular action or set of action.
Action Stubs: Action Stubs are below the condition stubs i.e lower left portion of the decision table.
Condition Entries: Rules are given in condition entries which contain several rows and columns. Values are given in upper right portion of the table.
Action Entries: In the action entry, every entry has some associated action or set of actions in the lower right part of the table and these values are called as outputs.

The future of manual testing in the age of AI

Manual testing never ends, because AI cannot think like a user and also cannot do domain-specific testing which only Manual tester can do. Manual testing has both confident and adaptive in testing. Manual testers can analyze the complex code and undergo testing but AI cannot.