DEV Community: Charishma

Understanding Selenium Architecture

Charishma — Tue, 14 May 2024 14:25:38 +0000

**Introduction to Selenium: **Selenium is a widely-used open-source automation tool primarily designed for web applications. It provides a suite of tools and libraries to automate web browsers across different platforms. The Selenium suite includes Selenium IDE, Selenium WebDriver, and Selenium Grid.

1.** Selenium Components:**

Selenium IDE: This is a Firefox and Chrome extension used for recording and playback of interactions with the browser. It's primarily used for prototyping and simple automation tasks.

Selenium WebDriver: WebDriver is the core component that provides APIs for interacting with web browsers programmatically. It communicates with the browser directly, controlling its behavior like clicking buttons, filling forms, etc.

**Selenium Grid: **Selenium Grid allows for parallel test execution across multiple browsers, operating systems, and machines. It helps in reducing test execution time and increasing test coverage.

2*. Selenium WebDriver Architecture:*

Client Libraries: These are language-specific bindings that provide methods and classes to interact with WebDriver. Examples include Selenium with Python, Java, C#, etc.

JSON Wire Protocol: WebDriver communicates with the browser using the JSON Wire Protocol over HTTP. It sends commands to the browser driver and receives responses.

Browser Drivers: Each browser (Chrome, Firefox, Safari, etc.) requires a specific driver (ChromeDriver, GeckoDriver, etc.) to establish a connection and control actions.

Browser Engine: The actual browser engine (WebKit for Safari, Gecko for Firefox, etc.) interprets and renders web pages based on instructions from WebDriver.

Execution Flow:

Test Script: Developers/Testers write test scripts using WebDriver APIs in their preferred programming language (like Python, Java).

Client Library: The test script interacts with the WebDriver client library, which serializes commands into HTTP requests.

JSON Wire Protocol: The client library sends HTTP requests to the browser-specific driver using the JSON Wire Protocol.

Browser Driver: The browser driver receives commands, translates them into browser-specific actions, and sends them to the browser engine.

Browser Engine: The browser engine executes actions (like clicking buttons, entering text) on the web page and sends responses back through the same route.

Significance of Python Virtual Environments

Isolation of Dependencies: Virtual environments in Python allow users to create isolated environments for projects. This isolation ensures that each project can have its dependencies without conflicting with system-wide Python installations or other projects.
Dependency Management: Virtual environments help manage project dependencies efficiently. Users can install specific versions of libraries for one project without affecting other projects or the system.
Version Control: Virtual environments facilitate version control for Python packages. Developers can freeze and save dependencies along with specific versions, ensuring consistent behavior across different environments.

Examples:

Testing: Test automation scripts using Selenium with Python can benefit from virtual environments to manage Selenium and related library versions specific to each project.

Web Development: A web developer may use virtual environments to isolate Django or Flask dependencies for different web projects.

Data Science: Data scientists can create separate environments for different machine learning projects, managing libraries like NumPy, Pandas, and TensorFlow independently.

Conclusion

Selenium's architecture encompasses various components like WebDriver, client libraries, browser drivers, and protocols, enabling seamless automation of web applications. Python virtual environments play a crucial role in isolating dependencies, managing versions, and maintaining project integrity, especially in scenarios like web development, data science, and test automation. Understanding these concepts empowers developers and testers to create robust automation solutions and manage Python projects efficiently.

Understanding Selenium: An Introduction to Automated Web Testing

Charishma — Fri, 15 Mar 2024 15:31:51 +0000

In the world of software testing, ensuring the quality and reliability of web applications is crucial. Imagine having a powerful tool that can interact with your web application just like a human user would. That's where Selenium comes into play!

What is Selenium?

Selenium is a powerful automation testing framework designed to streamline the testing process for web applications. It acts as your virtual assistant, capable of simulating user interactions such as clicking buttons, filling out forms, and navigating through web pages automatically.

Why Use Selenium?

As an automation tester, Selenium offers a n number of benefits that simplify and enhance the testing process:

Automated Testing: With Selenium, you can automate the testing of your web application, significantly reducing the time and effort required for manual testing.

Cross-Browser Compatibility: Different web browsers may interpret your application differently. Selenium enables you to write tests that run seamlessly across multiple browsers, ensuring consistent functionality for all users.

Regression Testing: Making changes to your code introduces the risk of new bugs. Selenium aids in running regression tests to ensure that your updates haven't broken any existing functionality.

Scalability: As your web application evolves, so does the complexity of testing it. Selenium allows you to scale your testing efforts efficiently by automating repetitive tasks and handling increasing test suites.

Integration with CI Tools: Selenium seamlessly integrates with Continuous Integration (CI) tools like Jenkins or Travis CI, enabling you to automatically run tests whenever new code is pushed, facilitating early detection of issues.

Cost-Effectiveness: Automated testing with Selenium saves both time and money compared to manual testing, as it reduces the need for human resources and accelerates the testing process.

How does Selenium Work?

At the heart of Selenium lies the WebDriver, acting as a bridge between your test scripts and web browsers. WebDriver communicates with the browser using browser-specific drivers (e.g., ChromeDriver, GeckoDriver), enabling seamless interaction with web elements.

You can write Selenium scripts using programming languages like Python, Java, or JavaScript, which interact with the WebDriver to execute commands such as navigating web pages, clicking buttons, inputting text, and validating results.

Advantages:

Open Source: Selenium is an open-source tool, which means it's freely available for everyone to use.

Cross-Browser Compatibility: Selenium supports multiple web browsers such as Chrome, Firefox, Safari, and Edge. This allows testers to ensure that their web applications work consistently across different browsers.

Support for Multiple Programming Languages: Selenium provides support for various programming languages including Java, Python, C#, and JavaScript.

Rich Set of Features: Selenium offers a comprehensive suite of tools and features for automation testing, including support for advanced testing scenarios like integration with Continuous Integration (CI) tools.

Large Community and Resources: Selenium has a large and active community of users, which means there are plenty of resources, tutorials, and forums available for assistance and knowledge sharing.

Disadvantages:

Limited Support for Non-Web Applications: Selenium is primarily designed for testing web applications and does not offer robust support for testing non-web applications such as desktop or mobile apps.

You need to have a knowledge of Selenium to work with it as you need to know Python and the framework as well.

Selenium cannot automate CAPTCHA and SMS-based OTP web applications.

Conclusion:

In short, Selenium is a superhero tool for automation testers. It helps you test websites quickly and accurately, saving time and ensuring quality.

Manual Testing

Charishma — Tue, 24 Oct 2023 15:07:04 +0000

*In this blog, we’ll see the basics of manual testing. We’ll also cover the advantages and disadvantages of manual testing. *

*What is manual testing? *

Manual Testing is a type of software testing, where testers will manually find defects and bugs. Test cases are executed manually, by humans, without any support from tools or scripts.

The goal of manual testing is to find errors, defects, and flaws in a software product. Manual testing is the most basic technology of all testing methods.

Manual testing is a process in which we compare the behavior of software (it can be a component, module, feature, etc.) with the expected behavior that we defined during the initial phases of SDLC.

Why do we need manual testing?

The basic usability, look & feel of the application can be tested and evaluated by humans. Manual testing will be executed as per the user experience perspective.

Manual verification always gives a broader perspective of the overall application. In this testing, testers write test cases test the software, and give the final report about that software. Manual testing is time-consuming testing because it is done by humans and there is a greater chance of human errors.

Every new application must be manually tested before it can be automated. Manual Testing requires more effort than automation testing because every time we need to retest the software when there is new functionality is added. When we do the regression testing, there are more chances to miss out on the test cases.

Automation testing can be done by tool/framework through the scripts. All the manual test cases will be defined through the code. Whenever testing needs to be done we can execute the scripts. With automation testing, we can reduce the total time of testing compared to manual testing. Here the chances of missing the bugs will be less. But all the test cases can't be automated, those test cases can be verified manually.

Types of Manual Testing:

*- White Box Testing: *

White box testing is an approach that allows testers to inspect and verify the inner workings of a software system and checks the internal code/logic, infrastructure, and integrations with external systems. This type of testing of software is started after a detailed design document.

The white box testing contains various tests, which are as follows:

Path testing
Loop testing
Condition testing

White box testing mainly focuses on the looping statements, flow checks, whether the conditions are working fine, whether the exceptions are handled correctly or not., etc.

*- Black Box Testing: *
The primary source of black box testing is a specification of requirements that are stated by the customer.

Here the testing will be done on the application from the user’s perspective without any knowledge of its implementation. Black box testing checks that the system as a whole is working as expected.

Black box testing mainly focuses on the requirements stated by the client. we verify the product/software end-to-end w.r.t test cases we designed. Here we test the behavior of the modules and boundaries.

Grey Box testing

The grey-box testing strategy combines white-box and black-box testing approaches. It involves access to internal coding to design test cases as white box testing and testing cases are done at the functionality level as black box testing.

Generally, Unit testing and integration come under Whitebox testing. System and Acceptance testing comes under black box testing.

*Process of Manual testing: *

Analyzing the requirements
Creating the test plan and test description documents
Review of the test plan
Execute the test plan
Test report and bug tracking, after fixing the bug retesting the software.

Let's see some advantages and disadvantages of manual testing.

Advantages:

Manual testing of an application identifies most of the issues, including the look and feel issues of the application.
Components like text, layout, icons, and UI and UX issues can be easily detected.
It is well-suited in case we make some unplanned changes to the application as it is adaptable.
Humans can observe, judge, and also provide the test case of manual tests.

Disadvantages:

Manual testing is time-consuming.
It isn't easy to find size differences and color combinations of GUI objects using a manual test.
Nonperformance testing is very difficult to perform.
Regression Testing cases are difficult to run in practical when there are continuous feature additions happening in the software.

Example:

Assume we need to test the login screen. We will write the test cases and execute them once the developer gives the build.

Advantages of manual testing
If we find any bugs like, text changes or error text is not appropriate, or the color mentioned by the customer and developed was different.
We can check all these things when we look at and feel the UI and how comfortable or easy to use by the human.

Disadvantages:
When there are complex features in the software. Frequently we are adding features to the software, we need to check each screen/module manually.
It will be difficult to check the same functionality in the repetitive builds, due to this we may miss some of the feature testing due to lack of time/deadlines we may commit.

If the tester gives the QA signoff without completing the testing it may cause bugs to the Realtime users.

Conclusion
In this blog, we tried to cover the topic of manual testing. Types of testing and advantages and disadvantages of manual testing.

Basics and types of testing

Charishma — Mon, 23 Oct 2023 12:59:22 +0000

*In this blog, we’ll see the basics of testing. We’ll also cover some of the differences between functional and non-functional testing and some of the types of both functional and non-functional testing. *

Importance of Testing

Human errors can cause a defect or failure at any stage of the software development life cycle. It makes the software more reliable and easier to use. A thoroughly tested software ensures reliable and high-performance software operation compared to without testing the software.

Functional and Non-Functional Testing
Firstly, we will discuss functional testing and its types and an example of functional testing.

Functional Testing In functional testing, we make sure that the functionality of the software meets the business requirements. We prepare tests to specifically focus on the business use cases. This means we prepare a set of inputs and the expected outputs and test the software/application for accurate results.

Functional testing mainly focuses on the software program for user interface, APIs, database, client/server connection, and many other features. Functional testing can be performed manually or through automation.

Functional testing mainly focuses on recognizing the test input of test data based on the requirements. Calculating the predicted results by using the input data and executing the test cases. Finally, compare the real and predicted results.

** Types of Functional Testing**

Unit Testing Unit testing is the “white box” approach to testing the functionality of the code against the requirements. We write tests to check if the written code works correctly. As a result, we can cover the defects and report those at the earliest phase of the Software Development Lifecycle.

As soon as a new feature is developed, we can write the unit tests in parallel to check that the feature works as expected even in unexpected scenarios. Unit testing can be done by developers/testers.

Unit testing will be done to validate the smallest possible unit of code such as a function or any conditions.

*Integration Testing: *

Integration testing is a method of testing how different units or components of a software/application interact with each other. It is used to identify and resolve any issues that may arise when different units of the software are combined. Integration testing is typically done after unit testing. We will verify that the individual modules and components work as efficiently after the integration as they do independently.

*System Testing: * We will test the whole application (complete/integrated software is tested) by a tester. We verify all the desired outputs for a specific set of inputs.

The order of the testing is firstly we perform the Unit testing, Integration Testing, and then System Testing. It is a type of Black-box testing. With the help of a Software requirement document along with the test cases, this testing will happen. the system testing will be done from the perspective of the end user whether the requirements are matched.

*4. Acceptance Testing: *
It is a level of software Testing in which software is tested for user acceptance.
→ It can be done by QA or clients.
UAT is done at the client side where software is actually used.
→ Alpha Testing: Done by the tester in the company in the presence of the customer.
→ Beta Testing: done by the customer to check software is okay and satisfies the requirement.
Note: We covered some of the important types of testing. Apart from the above, we have some other functional testing techniques like regression testing, sanity, smoke testing., etc.

Example for the functional testing:

To understand the different types of functional tests, here’s a test scenario for different kinds of functional testing techniques.

Test Scenario:

An online student portal on which

The user logs in with their Register No and password. The login page has two text fields for Register No and password. It also has two buttons – Login and Cancel.
After successful login it should have a home screen. On the home screen, the attendance tracker and list of holiday options should be there.
Attendance tracker - The tracker has every month's attendance and average attendance throughout the year.
List of holidays - This is a PDF file with the list of holidays in the current year.

Unit testing:
Here, I am explaining by taking an example for the first functionality.
module1:
Tc1: With the correct register no and password
TC2: With the incorrect register number and correct password
TC3: With the correct register number and incorrect password
TC4: With the incorrect register number and incorrect password

In the above test cases, only TC1 should pass, for the remaining test cases, it should through the appropriate error.

Integration testing:
Assume that after login functionality, the developer has developed the only home screen.

Here we will verify after successful login it is redirecting to the home screen. We will open the portal in different browsers, in incognito mode, and check whether the user is able to log in and access the home screen.

In the integration testing, we should concentrate more on the new addon functionality that causes any errors/defects to an existing functionality.

System testing:

Here we will execute all the test cases (positive and negative) after deployment for every module with respect to SRS.
Here we will check if any texts or buttons are placed in the right place.
Also, we will concentrate on whether their loading icon is placed (UI should communicate to the user to wait/process icons when there is a delay in fetching the data/while opening another tab.
Non-Functional Testing
We generally execute the non-functional testing after functional testing. In non-functional testing, we focus on the system such as performance, usability, reliability, and scalability. It ensures that the user gets the best experience while using the software. Non-functional tests are as important as functional tests since they help us understand how the system behaves under certain circumstances.

Non-functional testing targets the expectations of the customer. Non-functional testing can improve the product's reliability, performance, manageability, and accessibility.

Types of Non-functional tests:

*Performance testing: * Performance testing, is a non-functional testing technique performed to determine the system parameters in terms of responsiveness and stability under various workloads. Performance testing measures the quality attributes of the system, such as scalability.

*- Response time testing: *
Response Time Testing measures the time taken for one system module/API/Node to respond to the request of another.

*Load Testing: * Load testing is carried out to determine the behavior of a system under extreme load

*Stress Testing: * Stress Testing is done to check the robustness of the system under the
varying loads.

*Scalability Testing: * Scalability Testing can be done to check the performance of a
software application or system in terms of its capability to scale up or scale down the
number of user request loads.

Note: Other Non-Functionality Testing types of Volume Testing, Security Testing, Localization Testing., etc.
Example:
With the same example as functional requirements.
Non-functional requirements from the customer:
1000 active users, loading speed: 1 sec, Fetching the data: 2 secs.

We will test through tools like J-meter, postman., etc. the above testing required.

For the active users, we will perform the performance testing and load testing by increasing the active users from 10 to 1000 and calculating the average time.

To test the loading speed, we will note when the request happened and when we get a response for the respective action performed by the user.

We will test how much time it is taking to fetch the attendance over 3 months/6 months.

*Conclusion: *

In this blog, we learned the purpose of functional and non-functional testing. We also learned various types of functional and non-functional testing. Lastly, we explored the functional and non-functional testing techniques with examples.
Functional testing is performed using the functional specification provided by the client and verifies the system against the functional requirements.
Non-functional testing checks the Performance, reliability, scalability, and other non-functional aspects of the software system.

Testing Techniques

Charishma — Sun, 22 Oct 2023 15:49:53 +0000

Test case design techniques play a major role in planning, designing, and implementing tests for software applications. These techniques involve various steps to ensure the desired test cases to detect the bugs in the test software. These techniques help us to test all the software’s features and functionalities effectively.

*Why are test case design techniques used? *
These techniques are developed to reduce the testing process by identifying critical testing and reducing unused test cases. It helps better design and reduce the number of test cases to be executed. These techniques reduce data and more coverage.

*What are the advantages of test case design techniques? *

Possibility to reproduce a test.
Finding more bugs/defects.
Long-term maintenance.
Using these techniques, testers can identify complex scenarios, generate effective test data, and design test cases that evaluate full system functionality.

Types of Testing
There are two main categories of software testing techniques:

Static Testing
Dynamic Testing

Static Testing Techniques
Static Testing is done to avoid errors at an early stage of the development cycle.

Static Testing is a software testing technique that involves reviewing and analyzing the software documentation – design, or code without executing the software. This can save time, resources, and costs in the long run. Also, it catches bugs early.

We can identify issues like coding errors, inconsistent naming conventions., etc. That could negatively impact the software’s performance or quality.

Static testing will be done during the design, documentation, and development phases before dynamic testing occurs.

Few Examples of Static Testing

The primary goal of static testing is to reduce defect by reducing defects in the documentation from which the software is developed.

*Review: * is a type of static testing | done before execution
Review is a process or meeting during which a work product or set of work products, is presented to managers, users, and customers.

*Walkthrough Review: *
• The document owner guides the participants through the document according to his or her thought process
to achieve a common understanding and to gather feedback.

** Inspection Review: **
It is the most formal review type; this will be done by senior-level management. During inspection, the documents are prepared and checked thoroughly by the reviewers.

Dynamic Testing Techniques
It is a software testing technique that involves executing and evaluating a program or system during runtime. The main purpose of dynamic testing is to test the application with dynamic inputs- some of which may be allowed as per requirement (Positive test cases) and some are not allowed (Negative test cases).

*Why Do We Need to Perform Dynamic Testing? *

Dynamic testing helps identify bugs, errors, and defects in the software that may affect its functionality, reliability, or performance.
By executing the software with various inputs and scenarios, this testing ensures that it working as expected and meets the specified requirements from users/customers.
Detecting and addressing defects early stages of the development process, will reduce software failures or malfunctions.

*Few Examples of Dynamic testing: *

*Boundary Value Analysis (BVA): * To perform boundary value analysis, we need to test cases that include values at the boundaries of the input domain.

By testing these boundary values, we can ensure that the software program correctly handles the edge cases of the input and produces correct results for all possible inputs.
For each input variable, we will define the range of values and then determine the extreme values for each input variable.

Example:
To write the UPSC exam the person should have an age limit of 21 to 37 years old.

The following are possible test cases to check the boundary range for the above input.

min = 18(pass) 2. max = 37(pass)
min - 1 = 17(fail) 4. min - 1 = 36 (pass)
min + 1 = 19 (pass) 6. min + 1 = 38 (fail)
It shouldn't allow characters/special characters/spaces.

2.** Decision table: **

The technique is used if we have more conditions. Based on the condition we have to perform the action.

This test technique is appropriate for functionalities which has logical relationships between inputs (if-else logic). In the Decision table technique, we have to deal with combinations of inputs. While writing the test cases with a decision table, we have to consider conditions and their actions. We take conditions as inputs and actions as outputs.

It is a structured exercise to prepare requirements when dealing with complex business rules.

Example:
If the user has to submit a photo under particular situations, such as -
condition 1:
You can only upload images in the '.jpg' format.
condition 2:
a file with a size of fewer than 64 kilobytes

*Test cases: *

Test case 1 is passed, the remaining cases failed due to the conditions mismatch (this is not allowed as per the customer requirements).

*3. Use case Testing: *

Use case testing is a part of the functional testing technique that helps to identify and test the scenarios on end-to-end scenarios. It helps to identify the gaps in software that might not be identified by testing individual components. It is used to develop test cases at the system level or acceptance level.

The purpose of use case testing is to understand the end-user actions with the software/application as well as the system’s behavior.

The following things are carried out in the Use Case Testing

a) Use Case Identification -
b) Test Case Design
c) Positive and Negative Testing
d) Preconditions and Postconditions
e) End-to-End Testing
f) Test Data
g) Traceability
h) Regression Testing

Use-case testing is a valuable technique for ensuring that a software system meets its intended functional requirements and acts correctly when used by its intended audience. It aids in ensuring that the program meets user expectations and that frequent usage scenarios are extensively tested.

Example:
Students Web portal: Students can log in and check their attendance and results for each semester.

Module 1: Log in and log out with their registered number.

Module 2: Students can check their attendance for every semester.

Module 3: Students can check their marks for every semester.

Here each module is called a user case/user story.

When we want to test the module 2:

After logging into the portal, the user should be able to click the attendance symbol/text and it should redirect the attendance for every month in that semester.

In the attendance portal, the average attendance for a semester and along with that each month's attendance will be shown.

If the attendance <= 60:
the wheel will be in red color.
If the attendance >= 65 or <= 75:
the wheel will be in yellow color.
If the attendance >= 76:
the wheel will be in green color.

For the above requirements, will write the test cases and execute the testing.

*LCSAJ Testing: *

LCSAJ stands for Linear Code Sequence and Jump, a white box testing technique to identify the code coverage, which begins at the start of the program or branch and ends at the end of the program or the branch.

LCSAJ consists of testing and is equivalent to statement coverage.

LCSAJ Testing is nothing but a test design technique, which is used to design and create test cases, effective in executing the LCSAJ present in the program.

Example:
A user can check if he/she is eligible for gov jobs.
Min= 18, Max= 35

Test cases

Minimum age: >=18
Maximum age <=35
Minimum -1: 17
Maximum +1: 36

Software Testing

Charishma — Mon, 16 Oct 2023 13:22:18 +0000

*What is software testing? *

Software testing is an activity to detect and identify bugs in the software. The main objective of the testing is to release quality products to clients/customers. Testing is a part of the software development process to check whether the software is meeting the requirements/end-user expectations. The goal of a tester is to find the bugs, and errors, and verify and validate that the software is bug-free.

*What do we need to know about software testing? *

Before knowing about software testing, one should know about the software development life cycle. There are multiple SDLCs like the Waterfall, Agile, and spiral models. SDLC is a process to deliver the software to the customer.
SDLC consists of gathering the Requirements from the end user, Design, Deploy, Testing, and Maintenance.

To test the software effectively testers will follow the STLC (Software Testing life cycle). The STLC includes Test planning to the given requirements, Writing Test cases (positive, negative), Preparing the test env and test data set, Test execution, and Test report.

To test the application, one can select either manual or automation testing based on their requirement. Further testing was classified as functional and non-functional testing.

In functional cover Unit testing, Integration, System or UI testing, Validation testing, and user acceptance testing.
Non-functional requirements cover performance, load, stress, and security testing.

*What is the relevance of the software testing? *

Testing plays a very important part in SDLC, without doing any testing and releasing the product may have a lot of errors/bugs.

Example: Assume that one application is providing the following activities.
Signup screen, Login screen, and step counter.

Assume that the signup screen will have these functionalities like upload a photo, provision to add name, password, and confirm password.

After installing the application on the mobile, it may ask for permission to access the gallery or capture the image.

Someone has to test the application whether the application working properly when the required permissions are given. if the permission was not given by the end-user, then the software should be able to communicate with the user to give permission.

While uploading the photo, it should allow only jpeg files, it shouldn't allow extension files like PPT, word, PDF, etc. Every module and field should be tested to give a quality product to the end user.

Testing is very important to ensure that the application works properly. The user shouldn't be annoyed with UI, Functionality, or responsiveness between the User and the backend.