DEV Community: DHANUSH

PYTHON SELENIUM

DHANUSH — Sun, 11 May 2025 17:45:54 +0000

Python selenium archtecture is a layered system that allows developers to automate web browsers using the selenium webdriver APL.

Client Layer(Test Script Layer)

*Languages supported:
selenium supports multiple languages like python,java,c#, ruby,and javaScriot, in our case Python is used.

*Bindings:
The python bindings are wrappers that translate python commands into http requests understood by webdriver.

Selenium web driver API

webdriver is an interface that defines a set method for iterfacing with browsers (.get(),.click(),.send_keys(),etc.)
The webdriver API is language independent. Whenusing python,python binding convert method calls to JSON over HTTP.

JSON wire protocol/W3C webdriver protocal

This is communication protocol that enables communication between the client and the browser driver.
In older versions selenium used the JSON wire protocol.

BROWSER DRIVERS:

These are executables that act as middlemen between selenium and browsers.

Examples:

chromedriver for google chrome.
geckodriver for firefox
msedgedriver for microsoft edge.

BROWSERS.

The driver controls the browser to perform tasks like loading pages, clicking buttons filling forms. etc.
The browsers sends responses back to the driver, which sends them back to the client.

PYTHON VIRTUAL ENVIRONMENT

Dependency isolotion:

Prevents version conflicts between packages.
Each project can have its own set of dependencies.

Project portability:

Makes it easier to share projects (using requirments.txt) without worrying about system wide pacjages.

3.Cleaner global environmrnt:

keeps the global python installation untouched and clean

4.Reproducibillity:

Help in reproducing exact environment for development, testing and deployment.

EXAMPLE:

1.Without virtual environment

You install Flask==2.0.0 for project A.later,project B need Flask==1.1.2. installing both globally causes conflicts.

2.With virtual environment:

Project A

python -m venv venvA
source venvA/bin/activate
pip install Flask==2.0.0

Project B

python -m venv venvB
source venvB/bin/activate
pip install Flask==1.1.2

Each project run independently without conflict.

Test Plan for Sauce demo Website

DHANUSH — Thu, 08 May 2025 11:05:13 +0000

Test Plan Identifier Test Plan Version: V1.0 Project Name : sauce Demo testing plan

2.Introduction
Sauce Demo is a e-commerce application thet allows users to browse product add them to a shopping cart and complete purchases the purpose of this test plan is to valadate the application functionality,usability and compatibility with various browsers.

3.Test objectives:

verify that feature and workflows as expected.
Ensure the application is user friendly with ease of use
confirm compatibility across browsers and devices.

Scope > Core feature like login, product browsing cart management, filter option , checkout and payment. > Web application functionality on desktop, laptop and browsers. > Backend integration such as payment get way and databases.

Functional Testing
Product pages (add to cart, view details)
Shopping cart functionality
Checkout flow
Contact forms
Social media feed integrations (Instagram, TikTok)
Filter/search functionality.

Usability Testing Ease of navigation Clarity of product information Checkout process simplicity Mobile responsiveness

Accessibility:
Even if the app is technically functional, if users find it difficult to use, they will leave. Good usability improves conversion rates, customer satisfaction, and retention.

Page load times
Response times under high traffic
Load handling during peak hours (e.g., flash sales)

Users expect fast performance. Slow sites result in high bounce rates and lost revenue. Shopify stores, in particular, benefit from performance tuning to stay competitive.

Security breaches damage trust and can lead to legal and financial consequences, especially when handling sensitive customer data.

Why it's important:
Users access stores from various platforms. Incompatibilities can lead to broken layouts or features, losing potential sales.

Accessibility Testing:
Screen reader compatibility
Keyboard navigation
Color contrast
ARIA labels

PART 2
TEST SCENARIOS AMD CASES

1.Browse and View Products:

Users can scroll through collections, click on products, view images, descriptions, and prices.
Importance: Core to any eCommerce site — allows users to explore what's for sale.

2.Add Products to Cart:

Users can select product options (like size/color) and add items to the shopping cart.
Importance: Critical for enabling purchases; tests user decision flow and cart functionality.

3.Complete Checkout Process:

Users can proceed to checkout, enter shipping/payment details, and place an order.
Importance: This is where conversion happens. A smooth and secure checkout is essential.

4.Interact with Social Content (Shoppable Instagram Feed)

Users can engage with embedded Instagram or TikTok feeds and shop directly from social media images.
Importance: Enhances engagement, drives sales from social proof, and showcases real-world use.

5.Search and Filter Products

Users can use the search bar or filter by tags (e.g., color, category) to find specific products.
Importance: Helps users quickly find what they’re looking for, improving UX and conversion.

Functional Testing
Product pages (add to cart, view details)
Shopping cart functionality
Checkout flow
Contact forms
Social media feed integrations (Instagram, TikTok)
Filter/search functionality
Usability Testing
Ease of navigation
Clarity of product information
Checkout process simplicity
Mobile responsiveness
Accessibility (e.g., for visually impaired users)
Performance Testing
Page load times
Response times under high traffic
Load handling during peak hours (e.g., flash sales)
Security Testing
Secure checkout process (HTTPS, PCI compliance)
Protection against injection attacks
Access control (e.g., admin vs. guest permissions)

Why it's important:
Security breaches damage trust and can lead to legal and financial consequences, especially when handling sensitive customer data.

Compatibility Testing
Chrome, Firefox, Safari, Edge
iOS, Android devices
Desktop, tablet, mobile view
Integration Testing
Shopify platform integrations
Sauce app integration
Payment gateways
Social media feeds
Regression Testing
After bug fixes
When updating themes or apps
Adding new features (like a new social feed)
Accessibility Testing
Screen reader compatibility
Keyboard navigation
Color contrast
ARIA labels
Browse and View Products
Users can scroll through collections, click on products, view images, descriptions, and prices.

Importance: Core to any eCommerce site — allows users to explore what's for sale.

Add Products to Cart Users can select product options (like size/color) and add items to the shopping cart.

Importance: Critical for enabling purchases; tests user decision flow and cart functionality.

Complete Checkout Process Users can proceed to checkout, enter shipping/payment details, and place an order.

Importance: This is where conversion happens. A smooth and secure checkout is essential.

Interact with Social Content (Shoppable Instagram Feed) Users can engage with embedded Instagram or TikTok feeds and shop directly from social media images.

Importance: Enhances engagement, drives sales from social proof, and showcases real-world use.

Search and Filter Products Users can use the search bar or filter by tags (e.g., color, category) to find specific products.

Importance: Helps users quickly find what they’re looking for, improving UX and conversion.

2.GOAL

Ensure users can easily find and view product listings and details.
Verify that products can be added to the cart with correct variants.
Confirm that the checkout process is functional and secure from start to finish.
Ensure that social content is interactive and leads users to relevant product pages.
Verify that the search and filter functionality return accurate and relevant products.

Positive and negative:

Positive Test Scenario:

User navigates to the homepage and clicks on a product thumbnail.
User selects a valid size and color, then clicks "Add to Cart"
User fills out all required fields with valid data and clicks "Place Order".
User clicks a shoppable Instagram image and is redirected to the correct product.

Negative

User clicks a broken product link or tries to access a non-existent product URL.
User clicks "Add to Cart" without selecting a required variant (e.g., size).
User enters invalid credit card information (e.g., expired or incorrect number).
Image link is broken or points to a removed product.

Difference scenario and test case:

Feature:
Scope
Detail
Use
Audience

Test Scenario:
High-level idea
Brief, goal-oriented
Coverage planning
Stakeholders, QA leads

Test Case
Detailed steps and checks
Thorough, includes data and expected results
Execution and validation
Testers, automation engineers

TEST SCRIPTS

Positive Test Case
Test Case ID: TC_001_POS
Scenario: User views a product from the homepage.
Preconditions: User is on the homepage.
Steps:
Click on a product thumbnail.
Expected Result: Product detail page opens, showing image, price, and description.

Negative Test Case
Test Case ID: TC_001_NEG
User tries to open a non-existent product.
Preconditions: User has a broken product URL.
Enter an invalid product URL (e.g., /products/invalid-item).
Expected Result: User is shown a "Product not found" or 404 error page.

TEST SCRIPT

Test Script Structure
Setup
Launch browser
Navigate to URL
Test Steps
Interact with UI (fill forms, click buttons)
Validate expected results
Teardown
Close browser

SELENIUM

DHANUSH — Thu, 10 Apr 2025 18:32:28 +0000

WHAT IS SELENIUM:

An open source automation testing frame work used primarily for testing web application.
Lets developers write tests in languages like java, python, java script.
Can simulate user action like clicking buttons, filling out forms, and navigating pages across different browsers ( chrome, firefox,etc).
Often used in CI/CD pipelines for automated testing.

USE SELENIUM FOR AUTOMATION

CROSS BROWSER TESTING

Selenium supports all major browsers: chrome, firefox, edge, safari,etc..
MULTI LANGUAGE SUPPORT

You can write selenium scripts in several languages like python, java, c## ......
Open source:

it's free to use with a strong community and lots of plugins/extensions.

RELEVANCEOF SELENIUM IN AUTOMATION TESTING USING PYTHON:

SELENIUM IS HIGHLY RELEVANT IN AUTOMATION TESTING WITH PYTHON DUE TO SEVERAL KEY REASONS.

BROWSER AUTOMATION:

Selenium allows you to control real web browsers 9like chrome, firefox, edge) programmatically. this is essential for testing how web apps behave in a real environment.

END-TOEND TESTING:

With selenium you can simulate user interaction like:

Clicking buttons
Filling form
navigating pages
Uploading files this makes it ideal for end-to-end(E2E) and functional testing of web application.

3.** PYTHON INTEGRATON**

Python is a clean readable and powerful language. Selenium's Python bindings make it easy to:

Write concise and readable test scripts
Integrate with testing framework like Pytest or unittest
Generate test report or logs

CROSS-BROWSER TESTING

You can run the same test across different browsers to ensure compatibility.

COMMON MANUAL TESTING TECHNIQUES

DHANUSH — Mon, 02 Dec 2024 07:30:14 +0000

Exploratory Testing
Testing Without predefined test cases.
Ad hoc Testing
Unstructured and informal testing.
Black box testing
Testing without knowledge of the internal code or structure.
Focuses on input output and user experience.

4.white box testing
testing with knowledge of the internal code structure.

5.Funtional testing
Verifies the application function as expected based requirement.
User interaction
Business rules

BOUNDARY VALUE ANALYSIS

Include the minimum and maximum values of the input range.
also consider values just below and just above these limits

TESTCASE DESING

THE LOWER BOUNDARY
ONE VALUE JUST BELOW
THE UPPER BOUNDARY

DECISION TABLE TESTING

STRUCTURE:

Conditions: input factors or scenarios that influence the systems behavior.

PURPOSE:

To ensure that all possible combinations of conditions are tested.

ADVANTAGES OF DECISION TABLE TESTING:

Systematically handles complex combination of conditions.
Ensures full coverage of rules and decision paths.

THE FEATURES OF MANUAL TESTING IN THE AGE OF AI:

Human centric Evaluation
Critical Think And Adaptability
Testing AI And machine Learning Systems
Validation Of Automation Results
Testing Complex Scenarios
Collaboration With AI
Ethical Regulatory Testing
Focus On Non Functional Testing
maintaining Test Coverage In Dynamic Systems
Building Trust In AI

Python selenium architecture

DHANUSH — Tue, 13 Aug 2024 18:02:58 +0000

Selenium is a powerful tool for automating web browesrs and its architecture is designed to allow scripts to interact with web page just as a human would. Here a detailed breakdown of the selenium architecture.

Selenium components:

selenium web drive: this is core component of selenium.it provodes a programming interface to interact with web browsers. Web driver interacts with the browser directly without any middle layer.
selenium server: used for remote execution of web driver scripts.it acts as a middleware between the test code and the browser
selenium grid: used to distribute the execution of the cases across different environments machines.

Selenium Web Drive architecture:

selenium web driver follows a client server architecture. Here's how it structured:

Clint (Test script/code):
- The clint can any of the supportes programming languages (python, java, c#,etc).
- The script contains commands that are translstes into HTTP requests.
  - JSON Wire protocol:
- WebDriver uses the JSON Wirw protocal to communication between the client libraries and server.
- these requests contain actions like find elemenr, click, get, etc.
  - Browser specific driver
  - Each browser has a specific driver like chromedriver for chrome geckodriver for firefox, etc.
  - the webdrive sends the HTTP requests to the browser driver.

Selenium grid architecture

1.Hub

The cental point of the selenium grid.
receives test requests form the client.

2.Nodes

Nodes are actual machines where the tests are executed.
the hub forwards the test commands to the nodw which then executes the test on its local browser instance.

Execution flow in selenium:

test script initialization:
- Thu user writes test scripts in a language like python useing selenium libraries
  - Command Execution:
- the script generates WebDriver commands.
command are send as HTTP requests to the browse driver via JSON Wier protacol.
- Browser interaction:
  - THe browser drive receives the commands and translates them to the native browser language
  - The browser executes these commands.
- Resulting Reporting:
  - the browser driver collectes the results and sends them back as HTTP responses.

Advance features:

Page object model (POM): A desing pattern to creat object repositories for web UI elements.
Action Chains: Used for complex user interaction like drag and drop and right-click,etc.

Python selenium bindings:

Selenium, web driver: This model provide the methods and classes required to interact with browser.

*Find-element-by id(),,click(),send-key():

* Mothed to interact with web elements.

QUESTION NUM 2

The significance of the python virtual in environment:

The Python virtual environment is a critical tool for managing dependencies and configurations in Python projects. Here's why it's significant, along with some practical examples.

Significance of Python Virtual Environments:

Isolation of Dependencies:

What It Does:

A virtual environment allows you to create an isolated space for a Python project where you can install specific versions of libraries and packages without affecting the global Python installation.

Example:

Suppose you’re working on two projects, Project A and Project B. Project A requires requests version 2.20, while Project B needs version 2.26. By using virtual environments, you can create separate environments for each project, ensuring that each uses the correct version of requests without conflicts. Avoiding Conflicts:

What It Does:

Virtual environments prevent dependency conflicts by keeping project-specific packages separate from the system-wide Python packages.

Example:

If Project C relies on Django 2.2 but another project, Project D, requires Django 3.0, a virtual environment for each project ensures that they don’t interfere with each other’s Django versions.

Reproducibility:

What It Does:

Using virtual environments helps ensure that your project’s dependencies are consistent across different development setups. You can specify exact versions of packages in a requirements.txt file.

Example:

If you need to collaborate with a team or deploy your project to production, you can use pip freeze > requirements.txt to capture the exact versions of the libraries in your virtual environment. This file can then be used to recreate the environment elsewhere using pip install -r requirements.txt.

Ease of Management:

What It Does: Virtual environments simplify managing dependencies for multiple projects. You can activate and deactivate environments as needed, keeping your workspace organized.

Example:

You might be working on a data science project that requires specific versions of data processing libraries. By creating a virtual environment, you can quickly switch between this project and another one that uses different libraries without manual adjustments.