DEV Community: shruthisrivathsan

Selenium Architecture and Python Virtual Environment

shruthisrivathsan — Wed, 24 Jan 2024 09:19:16 +0000

Testing is a vital part of software development and no product can be launched in the market without proper testing, Selenium is a web automated testing tool that supports cross-browser testing across various operating systems. It was developed in 2004 by Jason Huggins to make manual testing easier using JavaScript.

Selenium WebDriver

It is a popular open-sourced library and a key component in automated testing in web applications.
It is a collection of APIs that enable testers to use Java, Python, C#, Ruby or JavaScript to create test scripts to automate web browser actions and retrieve information from the web.

Components of Selenium

The following are the main components of Selenium framework:

Selenium IDE

It refers to Selenium Integrated Development Environment. It is a Firefox plug-in that allows testers to record and play back scripts. Usually it is used as a prototyping tool because of its simplicity. Its main advantage is that it does not require in-depth knowledge of programming languages.

Selenium Remote Control

It is sometimes referred to as Selenium 1 because it was the first testing framework to be developed and was a preferred web automation framework. It is now an outdated technology that been replaced by WebDriver.

Selenium WebDriver

It is a major component of Selenium architecture that n allows automating user actions with web browsers and communicating with the browsers through open-source APIs.
It consists of the following:

Selenium Client Library consists of various language libraries for Python, Java, Ruby and other programming languages that can be used to write automation scripts and sends these commands to the network for execution. They are compatiable with W3C protocols like HTTP and TCP.
Selenium API is a set of rules and regulations that is used by a programming language to communicate. It helps in automation, without the tester understanding what is happening in the background.
JSON Wire Protocol converts the commands that are written into JSON, transmits to the client or web browser using the HTTP protocol for execution.
Browser Drivers are used to carry out communication between Selenium scripts, libraries and the respective browser.
Browsers such as Mozilla Firefox, Internet Explorer, Google Chrome 12.0.712.0 and above, Safari, Opera 11.5 and above, Android and iOS are supported.

Selenium Grid

It is used to run parallel tests on multiple devices running different browsers at different geographical locations simultaneously. It uses the Master-Slave Architecture, where a master device or process has control over how and when subordinate devices and processes use resources.

Python Virtual Environment

Virtual environment is a tool that is helps to keep the libraries and dependencies for each project separate from each other. It is also helps to prevent dependency issues that may arise and also improves the compatibility of the versions used. It is one of the most important tools used by developers and testers.

There are many advantages of using a virtual environment to work with the project. Some of them are as follows:

In a scenario where a user has multiple projects, where each project requires different dependencies, creating different virtual environments for each project makes it easier by avoiding unnecessary clashes.

It ensures that a project will run correctly using the right libraries and versions.

Virtual environment makes it easier to run the same project on different machines. When many people work on the same project at the same time, a commonly generated code can be shared along with all the dependencies.

Selenium

shruthisrivathsan — Mon, 22 Jan 2024 11:36:07 +0000

What is Selenium?

Selenium is an open-sourced automated testing tool that is used to test web applications across various browsers. It was developed by Jason Huggins in 2004 and was written in Java. It is a powerful automation tool that can be used to validate and verify a web application.

Why is Selenium so popular?

Selenium is easy to use as it provides a user-friendly interface that helps create and execute tests easily and effectively.
It is a publicly available automation framework that is freely accessible to anyone. It is therefore an open-sourced framework.
It saves a lot of time and effort as multiple tests can be run in parallel.
It is platform independent and can work with various operating systems like Windows, Mac, Linux/Unix.
It works with various web browsers like Safari, Chrome, Microsoft Edge and Firefox.
Tests can be coded in various programming languages including Java, Python, Ruby,Perl and PHP and Selenium converts it into compatible source in no time.
Selenium can be integrated with tools like JUnit and TestNG for test management.
It can also use with with testing frameworks like PyTest and Python Behave and also with CI/CD framework like Jenkins.
Selenium requires less hardware compared to other testing tools.

Although Selenium has a number of advantages, it also has a few disadvantages that need to be taken into consideration.
These include:

It has limited support for desktop applications and is mainly designed for online application testing.
The program writing time is high and requires good programming skills.
Selenium does not have built in reporting capabilities and testers must therefore depend on third-party reporting tools.
You cannot automate CAPTCHA and SMS based OTP web applications.
It has a small community so it lacks proper online support so you need to put a lot of efforts to find solution to your problem.
Seleniums automation depends on the browser's automation capabilities which can sometimes lead to inconsistencies across different browsers.

In conclusion, although there are a few disadvantages to using Selenium for automation testing, it is widely used because of it flexibility and easy of use.

Manual Testing

shruthisrivathsan — Mon, 30 Oct 2023 19:10:30 +0000

Manual testing is the process of testing a software manually by a tester, without using any automated tools.

Testing is done by following a set of predetermined tasks that need to be performed in order to check the performance of an application from an end user perspective.

The tester performs a series of tests to check if the inputs entered produce the desired output. In the process of testing a software, bugs and other errors are also corrected either by the tester or the developer.

For example, in order to check a website developed, user login credentials are verified by checking output when the username format or password is incorrect.

Benefits:

Flexibility:
Manual testing allows a tester to have a wide range of testing scenarios that can be tested. The tester is able to understand that end user experience and provide the necessary changes to improve user experience.

Early detection of bugs:
By manually testing the software, the tester is able to identify bugs and other serious flaws quickly and inform the developers. This avoids expensive rework later in the development cycle.

Detect more bugs:
Manual testers can detect subtle bugs in the software that may be overlooked in automation testing, for example visual inconsistency or usability.

Better understanding of user experience:
Manual testers gain a deeper knowledge of how the software works and how it is intended to work. This helps in finding potential issues and improves the end user experience.

Better testing coverage:
A manual test is more creative and can think more creatively to explore different paths to check the software.

Cost-effective:
Manual testing is more cost-effective than automated testing especially in case of small projects or limited budgets.

Drawbacks:

Susceptible to human errors:
Few bugs and defects may be overlooked due to tiredness, lack of focus and distraction.This is not the case with automated testing.

Time consuming:
Manually testing every feature and every function takes many extra hours while in case of automated testing, tests are performed in a fraction of that time.

Expensive:
Manual testing can be expensive especially in case of big projects as it requires more resources such as employees, machines and time.

Difficult to measure:
It is sometimes difficult to measure the efficiency of the testing process as it is difficult to keep track of the quantity and quality of tests performed, test coverage attained and the errors discovered.

In conclusion, manual testing has both benefits that make it crucial in software testing and drawbacks that can be challenging. It is important to take these into consideration before designing the testing process.

Functional and Non-functional testing

shruthisrivathsan — Wed, 25 Oct 2023 11:30:31 +0000

Software testing can be conducted in two different levels - functional and non-functional tests.

Functional testing is a type of software testing where the basic functionalities of the application are checked against a predetermined set of specifications. It uses black box testing techniques to check if the given input generates the desired output.

Non-functional testing verifies the application’s performance, reliability and user experience match the requirements.

Difference between functional and non-functional testing:

In simple terms, functional testing checks the functions and features of the application while non-functional testing checks the performance of these functions.
Functional testing checks if the key functions are operating and non-functional testing checks how the key functions are performing.
Functional testing verifies that the software meets the expectations of the end-user. Non-functional testing verifies that the application is easy to use and reliable.

Examples of Functional Testing:

In an application that is developed for online shopping, the following needs to be checked:

Correct username and password that pull the customer’s details.
Items displayed based on search.
The number of items and total cost of the items added to the shopping cart.
Interaction of the application with the payment portal.
Delivery options, dates and confirmation of address.

Testing is done in phases where all possible inputs are evaluated first to test their functionality. Next the tests are executed manually or automatically and finally check if the output matches the desired output. This is done through various testing methods.

The first level of testing is Unit testing and it is usually done as and when a single block of code is developed. It verifies that every small input generates a desired output. For example, the ‘Continue’ button should be disabled until both the user name and password are entered.
In integration testing, the interaction between the different components are tested to verify that they work well together. For example, when the user enters into their account, their address, preferences and other user preferences are accessible and are correct.
In interface testing the tester checks the interface of the system or components and how they work together. For example, when a user has selected the items and now proceeds to payment and delivery, the payment portal is checked for accuracy and security. -_ User acceptance testing_ is the final stage of testing before the application is deployed and it validates if the software aligns with user expectation and business needs.

Examples of non-functional testing:

Under this type of testing, all the non-functional aspects of the software are tested. This includes:

-_ Documentation testing_ is a type of black-box testing that verifies all the documents, user manuals, etc. It ensures that the documents on how to use the system matches with what the system does.
-Installation testing _checks if the application is installable in different operating systems without any bugs or errors.
-_Performance testing checks the responsiveness, speed and stability of the application under different work loads.
-_ Reliability testing is the final stage of non-functional testing where the software is checked for stability and reliability during long-term usage.
-_Security testing is done throughout the software development process and ensures that it is secure against potential security threats and attacks.

Both functional and non-functional testing are very important in delivering the best application to meet the requirements put forth.

Software testing methods

shruthisrivathsan — Fri, 20 Oct 2023 17:46:26 +0000

Software testing is important to check if the application does what it is supposed to do, is free of errors and bugs and meets the requirements. During the testing plan designing phase in STLC, test case scenarios are created to find defects in the test execution stage. These are done through various testing methods and testing techniques.

Testing methods are specific approaches used to test software.

They define the steps that the tester should follow to execute the test and what the desired result is. The following are the different methods of testing:

Black box testing: where the tester, as an end user, uses the software to test that it functions accurately in every situation and checks for performance defects, bugs, missing functions and other errors.

White box testing where the tester, with a complete knowledge of the source code and the design documents, analyzes the code.

Grey box testing where the tester, with a partial knowledge of the code, tests for errors due to improper structure.

Regression testing where the tester checks for new defects after updates and changes made to the original software.

Testing techniques are specific tools and techniques used to implement testing methods.

They can be used to test different aspects of the software such as functionality, performance, security and reliability. The test cases can be entered manually or through automated tools.There are four commonly used testing techniques, and they are as follows:

Boundary Value Analysis:

As the name suggests, it is a process of testing input values closer to the boundaries or outside values that could throw an error. Test cases selected for this testing are closer to minimum - maximum and inside -outside boundary.

Example of BVA:

Let’s take a case where the system accepts ages between 18 and 60. Here the valid test cases will be 17, 19, 59 and 61. Here 17 and 61 should show error as they are outside the boundaries.

Decision Table Testing:

This process of testing is used when there are multiple inputs and their combination could lead to different output. The input and their corresponding outputs are captured in a table form. This technique is very effective in testing the software with the requirements.

Example of DTT:

In the scenario of testing a software for checking a ticket price based on age(discounted price for people over 60) and membership status, the test cases will be
Members - < 60 and >61 and Non-members - <60 and >61.

Membership Status <60 >61

Members

Non- Members

Use case testing:

The entire software is tested from end- to- end from a user’s perspective. It finds gaps in the system that will otherwise not be found in testing individual components. It is also a description of how a user uses the system.

In the scenario of ordering pizza online with different options including size, toppings, extra cheese, drinks and add-ons, test cases will be created with multiple combinations to check for the right price.

Linear Code Sequence & Jump Testing:

This is a linear sequencing of code where the sequence starts from the beginning of the code or from a point where the control flow jumps. This is a white box testing method where the tester has access to the code.

Different test cases can be created in LCSJT and for every test case should specify the start of the sequence, end of the sequence and a specific target line.

In conclusion, testing techniques makes it possible to design better cases with lead to achievement of desired results.

Software Testing

shruthisrivathsan — Thu, 19 Oct 2023 11:16:36 +0000

Software testing is the process of evaluating and verifying that an application does what it is supposed to do.

Testing evaluates the softwares operability, checks for and fixes bugs as and when the software is developed and improves performance and security thereby making it more comfortable for the end users. Although the main benefit of testing is to find errors and defects, it also helps to understand the expected outcome so that the tester can improve the quality of the product.

Software development and testing go hand in hand and software testing can be thought of as the most crucial step in software development life cycle as it improves consistency and performance.

Software Testing - then and now:

Earlier software testing was separated from the development process and was often conducted in the later stage of software development life cycle, after the product was built or executed. It was difficult to fix errors and retest at this stage as it led to time constraint and increased cost.

Now, software testing is a part of the development process and the software developer and testers work side by side, thereby reducing time, errors and cost, as well as increasing the quality of the product.

Execution of tests right from the early stages of software development and throughout the entire process, streamlines the process and delivers a risk-free and an user-friendly product.

Over the years, software testing has evolved considerably as companies have adopted Agile and DevOps work environments. This has led to faster and more effective testing methodologies.

Why is testing important?

Finds defects early and saves money by avoiding extra costs to fix errors in the end product.
Improves security of the product as security issues or breaches can be fixed immediately, thereby producing a very secure software.
The expected quality of the product can be met by testing the software and making the relevant changes to improve the quality.
Increases customer satisfaction. Software is developed with the purpose of customer satisfaction. Different customers have different requirements. With the help of testing it is possible to know the expectations of the end users and make required changes so as to create the best application for their needs.
Helps check scalability - how well the software handles i. increased user traffic and data volume.
Helps determine the performance of the product.

Software Testing Life Cycle is the systematic approach devised to test software of an application to ensure it meets the requirements, is secure and free of bugs and defects. The following are the stages in STLC.

Requirement Analysis
Devise testing plan
Test case development
Set up test environment
Test execution
Test closure

Manual Testing:

In manual testing test cases are manually entered by a tester without any automated tools. The tester identifies bugs, defects and defects and fixes them. There are different methods(both functional and nonfunctional) of software testing. The following are a few:

Black box testing: This method checks the functionality of the software.
White box testing This method checks the internal structure, design and coding of the software.
Grey box testing This method is a combination of black box and white box methods where the tester has basic knowledge of the internal structure of the software.
Regression testing This method of testing checks if the updates or changes made have caused new defects in the existing functions.

Stages in Manual Testing:

Unit testing - each component of the code is checked individually
Integration testing - multiple units are integrated to check if the units to work together correctly
System testing - to check the system meets the desired requirements
User interface testing - checks user experience
Acceptance testing - checks if the software as a whole is fit for the end user.

Software testing is therefore most important as it helps create high-quality applications with very few or no errors. A system that meets or even exceeds customer expectations leads satisfied customers and to potentially more sales.