DEV Community: rajya shree

SELENIUM ARCHITECTURE

rajya shree — Fri, 23 Jan 2026 15:33:54 +0000

Selenium is designed to automate web browsers by sending commands from test scripts to browsers and receiving responses back. It basically follows a Client-Server architecture.

Main Components of Selenium Architecture:
-->Test Scripts(client language)
-->Selenium client Library
-->W3C webDriver Protocol
-->Browser Drivers
-->Real Browser

Test Script(Client Language):
It is basically written by tester using this programming languages:
-->c#
-->Java
-->Javascript
Example:
from selenium import webdriver
driver = webdriver.Chrome()
driver.get("https://google.com")

Selenium client Library:
It is a language-specific binding by selenium. Test Script and selenium WebDriver converts as a python commands into standard WebDriver commands.
Example: selenium-python, selenium-java, selenium-dotnet.

W3C WebDriver Protocol
A communication protocol used to send commands from Selenium client to the browser driver.
It enables language-independent communication and ensures uniform interaction between Selenium and browsers.

Browser Drivers:
Each browser has its own Driver
Chrome - ChromeDriver
Firefox - GeckoDriver
Edge - EdgeDriver
Safari - SafariDriver
Example: driver.find_element(BY.ID, "login").click()

Real Browser:
The actual browser installed on the system.
Executes:
Clicks
Typing
Page navigation
Returns results (success, failure, error).

SIGNIFICANCE OF PYTHON VIRTUAL ENVIRONMENT
A python Virtual Environment(venv) that allows you to install and manage python packages separately for each project without any conflicts of other projects.

Examples of Virtual Environment Usage
Example: Selenium Automation Project
pip install selenium pytest webdriver-manager
->Installed only for this automation project
->No impact on other projects

Tools for Virtual Environments:
Tools and Description
1.venv-->Built-in (recommended)
2.virtualenv-->Advanced features
3.conda-->Popular in data science
4.pipenv-->Combines pip + venv
5.poetry-->Dependency management

Summary
Python virtual environments make our projects independent, stable, and maintainable.

SELENIUM

rajya shree — Thu, 01 Jan 2026 15:47:24 +0000

WHAT IS SELENIUM?
Selenium is an open source automation testing tool used to automate web applications. It allows testers to simulates real user actions on a browser which are:

*Opening a website
*Clicking buttons and links
*Entering text in input fields
*Submitting forms
*Validating UI behavior

Selenium Components:
*Selenium Web Driver-It automates browsers
*Selenium IDE-It record and playback too
*Selenium Grid-Run tests in parallel on multiple machines

WHY DO WE USE SELENIUM?
Selenium offers many advantages:
1.Open source and free - No license cost
2.Supports multiple Browsers - Chrome, Firefox, Edge and safari
3.Supports multiple Languages - Python, c#, Java script, Ruby
4.Cross-Platform - It works on windows, mac-OS and Linux
5.Real browser Interaction - Tests the application exactly as a real user
6.Easy Integration - It works well with Testing frameworks like
-->Pytest
-->unittest
-->Behave(BDD)
-->Integrates with CI/CD tools(Jenkins, Github actions)
7.Strong Community Support - Huge documentation and online help

Relevance of Selenium in Automation Testing Using Python:
Simple & Readable Syntax
Python code is easy to write and understand
Faster automation development
Powerful Test Frameworks
PyTest → fixtures, reports, parallel execution
Unittest → built-in framework
Behave → BDD approach
Easy Maintenance
Less code → easier updates when UI changes
Supports Modern Automation Concepts
Page Object Model (POM)
Data-Driven Testing
Keyword-Driven Testing
Ideal for Agile & CI/CD
Python Selenium scripts can be triggered automatically in pipelines

Real-Time Use of Selenium in Automation Testing:
*Login pages
*E-Commerce flows(add to cart, checkout)
*Form Validation
*Regression Testing
*Smoke and Sanity Testing
*Cross-browser Testing

Manual Testing Techniques

rajya shree — Mon, 27 Oct 2025 06:07:40 +0000

WHAT IS MANUAL TESTING?
Manual testing is nothing but test cases are executing manually without using any automation tools. It relies on human intuition to identify the bugs and usability issues.

THE MOST COMMON MANUAL TESTING TECHNIQUES:

1.Black box Testing:
. This testing focusing on the functionality of the application without knowing its internal code structures.
. Its mainly used in system and acceptance testing.
example: To validate the authentication works correctly (Entering login credentials like username and password).

2.White box Testing
. In this Testing involves internal structures, logic, and code paths.
. Basically this testing is done by Developers.
example: checks the both branches of an "If-else" statement.

3.Grey box Testing
. Its the combination of both black box and white box techniques.
example: To test session expiration or anything in shopping cart.

4.Functional Testing:
It verifies the application features and focuses on business logic and outputs.
Types of Functional Testing:

Smoke Testing: It ensures that critical functionalities work after a new build.
Sanity Testing: It Processed on specific issues after minor changes.
Regression Testing: It ensures that new changes haven’t broken existing functionality.
Integration Testing:It checks interaction between modules and systems.
System Testing: It validate the complete system as a whole.
User Acceptance Testing: Testing by end users to ensure the product meets business needs.

5. Non Functional Testing:
Testing evaluates performance, usability, reliability and security.
Types of Non-Functional Testing:
Usability Testing: It ensures the product is user-friendly and intuitive.
Performance Testing: It evaluates responsiveness and stability under load during staging or pre-release.
Compatibility Testing: It ensures the application performs correctly across different environments like browsers, operating systems.
Load Testing: It checks how the application behaves under expected user loads.
Stress Testing: Test the system limits by increasing load beyond expectations.
Security Testing: It identifies vulnerability that could expose sensitive data.

Test Case-Based Technique

Positive Testing: It verifies the system behaves as expected with valid inputs.
Negative Testing: It checks how the system handles invalid or unexpected inputs.
Boundary Value Analysis: It tests that values at the edge of input ranges.
State Transition Testing: It tests that system behavior based on state changes.
Decision Table Testing: It uses the tables to represent combinations of inputs and expected outputs.
Error Guessing: To expect some common problem areas by tester. In this technique is not systematic but is effective for finding defects quickly.

Localization and Globalization Testing:

Localization Testing: It ensures the application works for specific regions like languages, currencies, data formats.
Globalization Testing: It verifies that the application can handle global data and users.

Conclusion:
Manual Testing brings creativity, human intuition and adaptability that machines cannot replicate. Manual techniques ensure that software is not only functional but also intuitive, accessible, and delightful to use.

BOUNDARY VALUE ANALYSIS

What is Boundary Value Analysis?
Boundary Value Analysis is one of the most commonly used black box testing techniques in software testing. This testing technique used to identify errors at the boundaries of input domains. It’s based on the observation that defects often occur at the edges of input values rather than in the middle. This technique is especially useful in functional testing, where inputs are validated against expected outputs.
Reason of Boundary Value Analysis
Some defects may often occur at boundaries because of:
-Programmers may use incorrect comparison operators like "<" instead of "<=".
-Users give input data at the minimum or maximum allowed limits.
-Edge conditions are more error-prone due to the logic or data type issues.
Core Principles of BVA
Boundary Value Analysis typically involves testing:
. Minimum boundary value
. Maximum boundary value
. Just below the minimum
. Just above the maximum
. Nominal (valid) value within the range
For example: The login form accepts an age from the range of 18–60:

Test values: 17, 18, 19, 59, 60, 61
This approach ensures coverage of:
Test values of Lower boundary 17: Invalid - Just below the minimum
Test values of Lower boundary 18,19: Valid - Just above the minimum
Test values of Upper boundary 59, 60: Valid - Just below the maximum
Test values of Upper boundary 61: Invalid - Just above the maximum

Types of Boundary Value Analysis
Two types of Boundary Testing Techniques:
i) Single Input Boundary Testing:
It used when the input field has a single variable or range(like age, marks, or salary)
Example: Testing minimum and maximum marks allowed in a grade field.
ii) Multiple Input Boundary Testing:
It used when multiple fields have their own boundaries.
Example: The login form accepts the age from the range of 18 to 40 and Experience 0 to 10 years.
This both set of boundaries must be tested individually and or combinations.

Real life Example
We check a Password Length

Valid range: 8–20 characters
Boundary value of test cases: 7, 8, 9, 19, 20, 21

i)Test value of 7 : Invalid Password

ii)Test value of 8, 9, 19, 20: Valid Password

iii)Test value of 21: Invalid Password

Pros of BVA
. Efficient: Targets high-risk areas with fewer test cases.
. Effective: Catches common boundary-related bugs.
. Simple to apply: Easy to derive test cases from specifications.

Limitations of BVA
. Assumes errors only occur at boundaries—not always true.
. May miss logic errors in the middle of input ranges.

Time to Use BVA
. Input fields with defined ranges (age, salary, quantity)
. During system testing, integration testing or acceptance testing
. Validations involving minimum/maximum constraints

Steps of Boundary Value Analysis

Identify input variables in the requirement function.
Determine valid input range for each variable.
Identify boundary values of minimum and maximum.
Add test cases for values just below or above boundary.
Execute test cases
Log defects if output moves from expected behavior.

Conclusion
Boundary Value Analysis is the most effective software testing. By focusing on the edges of input domains and helps uncover bugs that might otherwise slip through. Whether we testing a login form, a financial calculator, or a mobile app, BVA ensures your system behaves reliably at its limits.

DECISION TABLE TESTING

Definition
Decision Table Testing is a black box test technique used in software testing to represent and analyze different combination of inputs and their outputs in tabular form.
Steps to Create a Decision Table

1.Identify all conditions that affect the outcome.

2.List possible outputs.

3.Determine all possible combinations of condition outcomes (True/False).

4.Define which actions should occur for each combination.

5.Simplify the table by merging or eliminating duplicate rules.

6.Design test cases — each column (rule) corresponds to one test case.

Example: A user is eligible for a discount based on the following conditions.
Condition 1: User is a registered member.
Condition 2: Give 10% discount for Order amount is above rs.500.
Condition 3: Give 5% discount for Order amount is equal to rs.500.

Decision Table
Conditions Rule 1 Rule 2 Rule 3
Registered T T F
number

Order amount T T F
>500

Order amount F T F
<=500

Rules Explanation
Rule 1: Registered, Order amount > 500 - 10% discount
Rule 2: Registered, Order amount <=500 - 5% discount.
Rule 3: Guest user, Order amount<500 - No Discount.

Pros
Ensures complete coverage of all possible input combinations.
Simplifies complex business logic.
Helps identify missing conditions or unnecessary rules.
Easy to convert into test cases.

** Cons**
Can become complex for a large number of conditions.
Not suitable when conditions have many possible values (beyond True/False).
Maintenance can be difficult if rules change often.

## The Future of Manual Testing in the age of AI

Manual Testing is developing gradually not to disappearing. In future AI and human intuition which they are combines to play a vital roles, whereas human judgement will not replace.

Exploratory testing: AI can’t replicate the creativity and curiosity of a human tester exploring an app without a script.
Usability and accessibility: Understanding how real users interact with software—especially those with disabilities—requires empathy and context.
Edge cases and suspicion: Manual testers excel at spotting unexpected behaviors that automated scripts might overlook. Skills Manual Testers Need to Thrive To stay apt, manual testers should:
- Learn AI basics: Understand how AI models work and how they influence testing.
- Master exploratory techniques: Become experts in unscripted testing and user empathy.
- Collaborate with automation engineers: Bridge the gap between manual and automated testing.
- Use AI tools: Embrace platforms that assist with test planning, defect prediction, and analytics.

Soft Skills for

Analytical thinking
Creative problem solving
Effective communication
User empathy and design thinking

Summary
Overall in the future, Human Intelligence and machine assistance is the
manual testing in the age of AI.
Things we know, AI handles repetitive, data-heavy, and predictable tasks.
However Humans can handle creative, contextual, and judgment-based testing.
Thus the combination ensures higher software quality, better UX, and faster releases.

Boundary Value Analysis(BVA)

rajya shree — Sat, 25 Oct 2025 17:28:05 +0000

Test values: 17, 18, 19, 59, 60, 61
This approach ensures coverage of:
Test values of Lower boundary 17: Invalid - Just below the minimum
Test values of Lower boundary 18,19: Valid - Just above the minimum
Test values of Upper boundary 59, 60: Valid - Just below the maximum
Test values of Upper boundary 61: Invalid - Just above the maximum