DEV Community: Vignesh

Task 18 Python Selenium

Vignesh — Thu, 23 May 2024 15:08:30 +0000

The Selenium architecture for Python is structured to facilitate robust and flexible web automation and testing. It involves several key components working together seamlessly:

Selenium WebDriver WebDriver is the core component that interacts directly with web browsers. It provides a programming interface to write and execute test scripts.

2.Language Bindings
Selenium supports multiple programming languages, including Python. These language bindings allow you to write test scripts using Python's syntax. The selenium package can be installed via pip:

pip install selenium

3.JSON Wire Protocol
WebDriver uses the JSON Wire Protocol to communicate with browser drivers. This protocol defines a RESTful web service for performing operations like navigating to a page, clicking elements, and entering text.

4.Browser Drivers
Each browser has a specific driver that acts as a bridge between WebDriver and the browser:

ChromeDriver for Google Chrome
GeckoDriver for Mozilla Firefox
IEDriverServer for Internet Explorer
SafariDriver for Safari

Browsers Selenium can automate any browser that is compatible with the corresponding browser driver, such as Chrome, Firefox, Safari, Edge, and Internet Explorer.

Detailed Flow of Selenium Python Architecture
1.Script Execution: The Selenium script is executed, containing commands like opening a browser, navigating to a URL, and interacting with elements.
2.Python Bindings: These bindings translate Selenium commands written in Python into HTTP requests using the JSON Wire Protocol.
3.WebDriver: Communicates with the appropriate browser driver by sending these HTTP requests.
4.Browser Driver: Converts JSON Wire Protocol commands into browser-specific actions and executes them.
5.Browser Interaction: The browser performs the actions, such as loading a webpage or clicking a button.
6.Response Handling: The browser sends responses back to the browser driver, which then sends them to the WebDriver.
7.Result Return: WebDriver returns the results to the Selenium script through the Python bindings, allowing the script to handle the outcomes and perform further actions.

Integration with Testing Frameworks and CI/CD
Selenium is often integrated with testing frameworks like PyTest or Unittest for better test management and reporting. Additionally, integrating Selenium tests with CI/CD tools like Jenkins or GitHub Actions allows for automated test execution as part of the build process, ensuring new code changes do not introduce bugs.

This architecture allows for efficient and effective web browser automation, making Selenium a powerful tool for web application testing.

A Python virtual environment is a tool that helps to keep dependencies required by different projects in separate places, by creating isolated environments for each of them. This is especially significant for maintaining project dependencies and avoiding conflicts. Here are the key benefits and examples illustrating the significance of using Python virtual environments:

Key Benefits

Dependency Management: Different projects might require different versions of the same library. Virtual environments help manage these dependencies without conflicts.
Isolation: Each virtual environment is isolated from the others, ensuring that the libraries and dependencies in one environment do not affect another.
Portability: Virtual environments can be easily recreated on different machines, ensuring consistent development environments.
Clean System: Prevents global installation of packages, keeping the system Python environment clean and uncluttered.
Reproducibility: Ensures that the same dependencies are used across different stages of development, testing, and production, aiding in reproducibility of code execution.

Examples

Example 1: Different Django Versions

Imagine you have two projects: Project A and Project B. Project A uses Django 2.2, while Project B uses Django 3.2. Installing these different versions globally would cause conflicts. Here’s how you can handle this with virtual environments:

Creating Virtual Environments:

   python -m venv projectA_env
   python -m venv projectB_env

Activating Virtual Environments:

On Windows:

 projectA_env\Scripts\activate
 projectB_env\Scripts\activate

On Unix or MacOS:

 source projectA_env/bin/activate
 source projectB_env/bin/activate

Installing Dependencies:
- For Project A:
```
 pip install django==2.2
```

For Project B:
```
 pip install django==3.2
```

Deactivating Virtual Environments:

   deactivate

Selenium

Vignesh — Thu, 23 May 2024 14:48:47 +0000

Selenium is a widely-used tool for automating web browsers, essential for anyone involved in web development and testing. It allows users to write scripts that interact with web applications just as a human would, performing tasks such as clicking buttons, filling out forms, and navigating pages. This capability makes Selenium invaluable for testing web applications, ensuring they function correctly across different browsers and platforms.

One of the primary reasons to use Selenium for automation is its ability to handle repetitive tasks efficiently. For example, suppose a developer needs to test a login form. Manually entering the username and password and clicking the login button every time can be time-consuming and prone to errors. With Selenium, a script can be written to automate this process, performing the task quickly and accurately each time. This automation not only saves time but also ensures consistency in testing.

Selenium supports multiple programming languages, including Python, Java, C#, and JavaScript, which makes it accessible to a broad range of developers. This flexibility allows teams to write tests in the language they are most comfortable with, integrating seamlessly into their existing development workflows. Additionally, Selenium is compatible with various browsers like Chrome, Firefox, Safari, and Internet Explorer, which is crucial for cross-browser testing.

For example, a quality assurance (QA) engineer can use Selenium to write a test script that opens a web application in multiple browsers, checks that all elements are displayed correctly, and verifies that all functionalities, like form submissions and navigation links, work as expected. This automated testing ensures that users will have a consistent and error-free experience regardless of the browser they use.

Manual Testing

Vignesh — Sat, 02 Mar 2024 06:05:30 +0000

Manual testing is a type of software testing where testers manually execute test cases without using any automation tools or scripts. In manual testing, testers interact directly with the software application, exploring various features and functionalities to identify defects, bugs, or areas of improvement.

Benefits of Manual Testing:

Human Judgment: Manual testing allows testers to apply their critical thinking skills, domain knowledge, and intuition to identify issues that automated tests might miss. Human judgment can often detect subtle issues that automated tests may overlook.

Exploratory Testing: Manual testing is particularly effective for exploratory testing, where testers explore the application dynamically, simulating real-world user interactions to uncover unexpected behavior or defects.

Cost-Effectiveness for Small Projects: For small-scale projects or projects with frequently changing requirements, setting up automation frameworks might be more time-consuming and costly than manually testing the software.

Usability Testing: Manual testing is well-suited for evaluating the usability of an application, as testers can provide subjective feedback on the user interface, workflow, and overall user experience.

Drawbacks of Manual Testing:

Time-Consuming: Manual testing can be time-consuming, especially for repetitive test cases. Testers need to execute each test case step by step, which can slow down the testing process, especially for large and complex applications.

Human Error: Manual testing is prone to human error, as testers might overlook certain scenarios or make mistakes during test execution. This can lead to incomplete test coverage or inaccurate test results.

Limited Reusability: Test cases in manual testing are typically not reusable, meaning testers have to repeat the same tests for every new release or iteration, increasing testing effort and time.

Scalability Issues: Manual testing becomes increasingly challenging to scale as the size and complexity of the application grow. It may not be feasible to manually test all aspects of large-scale enterprise applications within a reasonable timeframe.

Examples:

User Interface Testing: Manual testing is commonly used to evaluate the visual layout, responsiveness, and usability of the user interface across different devices and screen sizes.

User Acceptance Testing (UAT): Manual testing is often employed during the UAT phase, where end-users validate whether the application meets their requirements and expectations before it goes live.

Functional Testing & Non Functional Testing

Vignesh — Sun, 25 Feb 2024 06:43:21 +0000

System setting is a level of testing done only by testers and it comes under black box testing. This testing is done at 2 different levels
*A. Functional testing
B. Non Functional testing. *

A. Functional testing is nothing but testing the functional values and is done by 3 major types
**1. Smoke testing

Sanity testing
Regression testing**
Smoke testing is a build verification test and it tests the high priority test cases to ensure whether a basic field is working correctly.
For example: If we are testing a sign-in page, with 2 columns username and password, in smoke testing we test whether we can enter the values into username section and password section. If that fails, then there will be no need to execute other test cases and this high priority fails.
Sanity testing is done when the website or the product is enhanced. Sanity testing tests the enhanced part alone.
For example: _In the sign-in page, if there is an enhancement of the sign-up button, sanity testing tests the sign-up button test cases alone. _
Regression testing is also done when the website or product is enhanced but this tests the existing functionalities.
For example: When the sign-up button is enhanced in the sign-in page, regression testing executes the high priority test cases of username and password, takes it into the regression suite and tests whether those work fine.
Since we keep on testing old high priority test cases when enhancement is done, automation testing comes into place to avoid time waste and errors.

B. Non functional testing is done to test the non functional values like
**1. Performance testing

Usability testing
Compatibility testing
Accessibility testing**
Performance testing is done to check the load and stress of the product. A load is the maximum amount set and stress is testing beyond the maximum point. The end point is the software or product should be working fine.
For example - _On a Great Indian festival at Amazon, lakhs of users visit and buy from the site. If the load is set at 2 lakh customers per second, it should work fine at this load and work beyond this load, that is for 2.2lakhs customers should also be handled by the website without getting crashed. _
This testing is done by a performance engineer using the Jmeter tool.
Usability testing is to make sure the GUI or Graphical User Interface works fine in the product. This testing makes sure the look and feel is satisfied and user friendly.
For example - _The login button is usually set at the top right corner in many of the websites. Changing that will cause confusion and hindrance to the user. So this testing makes sure all these are rectified. _
Compatibility testing is to make sure the product works across all platforms, no matter of devices or OS.
For example - _The Amazon website should work fine on Windows laptops as well as Mac desktops. _
Accessibility testing is testing based on a client's requirement that even differently disabled people should also use the product.

Types of Testing

Vignesh — Tue, 20 Feb 2024 07:57:38 +0000

Boundary value analysis as the name stands is testing between the values on a set boundary. One value lesser and One value higher will be taken for testing and testing takes place to make sure the desired values work bug free. For example if we take values from 0 to 10, for boundary value analysis we pick from -1 to 11. When it comes to decision table testing, it is checking all the possibilities in True or False method. If we pick 2 fields, there will be 4 tables in decision table testing. For example, if we choose Sign in page and take the 2 fields, user name and password, the conditions for testing can be correct user name & correct password, correct username & wrong password, wrong username & correct password and wrong username & wrong password. We will will get 4 columns in the combination of T&T, T&F, F&T and F&F. Use case testing is checking the possibilities of finding bugs. For a sign in page, there will be numerous possibilities and combinations to test the product.

Software Testing

Vignesh — Tue, 20 Feb 2024 05:54:13 +0000

Software Testing is a process of testing a product or software either manually or by automation to identify the bugs and provide a bug free software to the users or client. We need to know the tools and have the responsibility to place ourselves in end product user's shoes while testing. The main relevance of software testing is making the product bug free and not to compromise on the performance of the product or software.