DEV Community: sankar

TASK - 4

sankar — Wed, 10 Apr 2024 15:02:37 +0000

Manual testing, Benefits and drawbacks of manual testing and also a example
Manual testing:

It is a vital quality assurance process in software development that relies on human testers to access the functionality, usability and quality of a software application. It involves the systematic execution of test cases and scenarios, where testers interact with the software as end-users would, identifying defects, validating requirements and assessing the user experience.

In manual testing, testers meticulously navigate through the software, inputting with various features to ensure they perform as expected. They also verify that the application functions correctly across different operating system, devices and browsers providing a holistic view of its compatibility.

This form of testing is crucial for identifying issues that automated testing tolls may overlook, including visual discrepancies, usability problems and unexpected user behaviors.

Manual testing is particularly valuable during the early stages of development, where rapid changes and frequent updates may render automated tests obsolete. It is also essential for users acceptance testing, ensuring that the software aligns with business requirements and meets user expectation.

While automation can improve testing efficiency for repetitive tasks, manual testing remains indispensable for its ability to provide qualitative insights, adaptability to changing project dynamics, and its capability to offer a more comprehensive evaluation of software quality.

Benefits of manual testing:

Exploratory testing: Manual testers can employ exploratory testing techniques to uncover unforeseen issues providing valuable insights into the software's behavior that may not be covered by predefined test cases.

Usability evaluation: Manual testers assess the user interface and overall user experience, identifying usability issues, design flaws and inconsistencies that automated tests may miss.

Real world scenarios: Testers simulate real world user interactions, ensuring that the software correctly in diverse situations and contexts.

Early testing: Manual testing can start in the early stages of development when automated test scripts might not yet be available or practical helping to catch defects sooner.

Adaptability: Manual testers can quickly adapt to changing project requirements, making it easier to accommodate last-minute changes or rapidly evolving software.

Comprehensive testing: Human testers can provide a holistic evaluation of software quality, considering factors like intuition, domain knowledge and subjective user feedback.

Complex testing: Certain aspects of testing such as security testing, load testing and accessibility testing often require manual intervention for through examination.

8.Rapid feedback: Manual testers can provide immediate feedback during testing, helping developers identify and rectify issues promptly.

Cost-effective for small projects: For smaller projects or projects with limited budgets, manual testing can be more cost-effective than setting up and maintaining automated testing infrastructure.

Early user feedback: Manual testing allows for early involvement, which can lead to valuable insights before a software release.

Some of the drawbacks of manual testing

Human error: Manual testing is susceptible to human error, leading to potential inaccuracies in test execution and results. Testers may overlook issues or make mistakes in data input, comparing the reliability of testing process.

Resource intensive: Manual testing can be time consuming and labor intensive, requiring a dedicated team of testers for extensive test coverage, This can result in higher testing costs and longer development cycles.

3.Limited repetition: Manual tests cannot be easily repeated on a large scale, making it challenging to perform thorough regression testing when changes are made to the software.

Subjectivity: Testers assessments can be subjective, leading to variations in test results based on individual perspectives, bias or experience.

Incomplete test coverage: Manual testing may not cover all possible test scenarios and edge cases, leaving some areas of the software untested.

Slow feedback: Manual testing may slow down the feedback loop between testers and developers, especially in large projects, where test execution and reporting can take considerable time.

Not suitable for performance testing: Manual testing is impractical for conducting performance, load or stress testing where automated tools are necessary to simulate large-scale user interactions.

8.Costly for long-term projects: In long-term projects with frequent releases and updates, manual testing can become cost-prohibitive due to its resource requirements and time constraints.

9.Ineffective for continuous integration: In a continuous integration delivery environment, manual testing cannot keep up with the rapid pace of code changes and deployments.

Difficulty in scaling: Scaling manual testing for large, complex applications or distributed systems can be challenging and may require substantial coordination and resources.
Example for manual testing:

Test scenario: Verify the login functionality of a web application.

Test steps:

Launch the application: Open the web browser and navigate the login page of the application.

Enter valid credentials: In the username and password fields, input valid login credentials.

Click the login button: Click the "LOGIN" button to submit the credentials.

Verify successful login: After clicking the login button, the system should validate the credentials and redirect the user to the dashboard or homepage.

Enter invalid credentials: In the username and password fields, input incorrect login credentials.

Click the login button: Click the "LOGING" button again.

Verify error message: The system should display an error message indicating that the login failed. Confirming that the error message is clear and informative.

Forgot functionality: Test the "FORGOT PASSWORD" functionality by clicking on to "FORGOT PASSWORD" link. Follow the steps to reset the password and confirm that the rest process works as expected.

Logout functionality: Log in with valid credentials and then test the logout functionality by clicking the "LOGOUT" button. Confirm that the user is logged out and cannot access protected pages without logging in again.

Browser Compatibility: Perform the login tests in different web browsers to ensure cross-browser compatibility.

Mobile responsiveness: Test the login functionalities on various devices to ensure the application is responsive and displays correctly.

Security testing: Attempt to perform security testing, such as entering SQL injection or cross-site scripting attempts in the input fields ,to confirm that the application is secure against common vulnerabilities.

Performance: Check the login response time and performance by simulating multiple login attempts concurrently to assess how the application handles load.

Localization: If the application supports multiple languages, test the login functionality with different language settings to ensure text and UI elements are localized correctly.

User experience: Evaluate the overall user experience during the login process, including the intuitiveness of the interface and the clarity of error messages.

Boundary testing: Test the login functionality with edge cases such as extremely log usernames or passwords to ensure the application handles them gracefully.

Session management: Verify that the application maintains user sessions correctly.

Cookies and security tokens: Verify that cookies and security tokens are used correctly in the login process to enhance security;.

Compatibility with third-party services: If the login process involves third-part authentication services, test their integration to ensure a seamless experience.

Accessibility: Check that the login page complies with accessibility standards to ensure it is usable by people with disabilities.

After conducting these manual tests, testers would document their findings, including any defects or issues encountered, which would then be communicated to the development team for resolution.

TASK - 3

sankar — Wed, 10 Apr 2024 14:55:47 +0000

The difference between functional testing and non-functional testing with example
Functional testing:

Functional testing is a crucial quality assurance process in software development that evaluates whether a software application functions correctly according to its specifications and requirements. It focuses on testing the functionality of the application, ensuring that it performs its intended tasks accurately.

Here is an example for functional testing

Consider a basic e-commerce website that allows users to browse products, add items to their carts, and complete a purchase. Functional testing for this application would involve testing various aspects of its functionality:

User Registration: verify that users can successfully create an account with valid information.

Product search: Test whether the search function accurately retrieves products based in keywords, categories or filters.

Add to cart: Check if users can add products to their cart and that the cart accurately displays the selected items and their quantities.

Checkout process: Validate that users can process through the checkout process smoothly. This includes entering shipping information, payment details and reviewing the order before confirming it.

Payment processing: Ensure that payment are processed accurately, with appropriate validation for credit card information, addresses and transaction confirmations.

Order confirmation: Verify that users receive an order confirmation email after completing a purchase.

User account: Test various account-related functionalities, such as updating personal information resetting passwords, and viewing order history.

Compatibility: Check if the website functions correctly across different browsers and devices.

Functional testing involves both positive testing and negative testing. Test cases are designed based on the applications functional requirements, and test results are compared against expected outcomes to identify any deviation or defects.

Automated testing tools and manual testing can be used for functional testing. Regression testing, which retests existing functionalities after changes, is also a vital part of the process to ensure that new updates or features do not break existing functionality

In summary, functional testing is essential for assuring the reliability and correctness of software applications, and it involves systematically testing each function and feature to ensure it meets the specified requirements like the example provided for e-commerce website

Non-functional testing:

Non-functional testing often referred to as quality testing, focuses on evaluating the characteristics of a software system that are not directly related to its functional behavior. These characteristics include performance, usability, reliability, scalability, security and more.

Performance testing assesses how well a software system performs under various conditions. It ensures that the application meets performance expectations and can handle a specified load.

Some example scenarios for performance testing:

Load testing: This assesses how the system performs under expected and peak loads. For instance, an e-commerce website, load testing would involve simulating a large number of concurrent users accessing the site to ensure it can handle heavy traffic during sales events.

Stress testing: Stress testing pushes the system beyond its specified limits. For example, lets take a mobile banking app, stress testing would involve initiating transaction with a higher-than-usual number of concurrent users to identify performance bottlenecks or system failures.

Scalability testing: Scalability testing checks if the system can handle increased load by adding more resources or servers. It ensures that the application can scale smoothly as the user base grows.

Response time testing: This measures how quickly the system responds to user actions. For a video streaming service, response time testing would evaluate the time it takes to start playing a video after a user clicks the play button

Usability testing:

It focuses on the user friendliness and overall user experience of the software. It ensures that the application is easy to navigate and meets user expectations. For example:

User interface testing: Evaluates the design and layout of the user interface. Testers assess whether buttons, menus and navigation are intuitive and user-friendly.

Accessibility testing: Checks if the application is accessible to users with disabilities, ensuring compliance with accessibility standards

Security testing:

Security testing identifies vulnerabilities and weaknesses in the software that could lead to breaches or data leaks

Penetration testing: Simulates cyberattacks to identifies vulnerabilities that hackers could exploit, suck as SQL injection or cross site scripting vulnerabilities.

Authentication testing: Verifies the effectiveness of users authentication mechanism, ensuring that only authorized users can access sensitive information.

So, non-functional testing is crucial to ensure that software not only functions correctly but also meets performance usability, security, and other critical criteria. Conducting these tests helps identify and mitigate risks and improve the overall quality of the software product.

TASK - 2

sankar — Wed, 10 Apr 2024 14:51:37 +0000

Boundary value analysis, decision table testing, use case testing, LCSAJ testing
Boundary value analysis:

Boundary value analysis is a software testing technique used to identify defects at the edges or boundary of input ranges. The idea behind this technique is that errors often occur at the extremes of input values, where the behavior of the software might differ from the expected behavior. It helps in identifying these vulnerability and improving the robustness of the software

In boundary value analysis, you test the minimum and maximum valid values, as well as values just below and above those boundaries. These are the points where issues are most likely to occur due to the transition from one range to another

Example for boundary value analysis:

Let's consider a simple scenario where you are testing a system that calculates the fare for aa taxi ride based on the distance traveled

Requirement: The taxi fare is calculated a 2 rupee per mile

In case, boundary value analysis would involve testing various scenario around the boundary values:

*Minimum value: Test the system with the minimum allowed distance. This is a boundary where the fare should still be calculated correctly. If the fare calculation fails at this point, it indicates a problem with the minimum boundary condition.

*Just below the boundary: Test the system with a distance value slightly below the minimum. This tests whether the system handles invalid input appropriately. The expectation here is that the system should reject negative distance.

*Maximum value: Test the system with the maximum allowed distance. This is another boundary where the fare calculation should work accurately. A failure here might indicate a problem with handling larger values.

*Just above the boundary: Test the system with a distance value slightly above the maximum limit correctly

By performing these tests, you are ensuring that the software handles both valid and invalid inputs at the input range effectively. This can help identify potential issues and make the software more robust.

Decision table testing:

Decision table testing is a technique used to test behavior of a system based on different combinations of input and conditions. It's particularly useful when a system's behavior depends on multiple conditions and their combinations. Decision tables provide a structured way to define these condition and their corresponding actions or outcomes.

Example:

Let's consider a scenario where you are testing a login system that grants access to users based on their user type and the time of day

Conditions

*User type: Regular user(r), admin(a)
*Time of day: Daytime(d), nighttime(n)

Actions:

*Grant access(g)
*deny access(d)

Condition User type time of the day action
case 1 r d g

case 2 r n g
case 3 a d g
case 4 a n d

In the decision table, each row represents a specific combination of condition and the corresponding action that be take. Let's see an example

Case 1: If the user is a regular user and it's daytime, they should be granted access.
Case 2: If the user is a regular user and it's nighttime, they should still be granted access.
Case 3: If the user is an admin and it's daytime, they should be granted access.
Case 4: If the user is an admin and it's nighttime, they should be denied access.

By testing scenarios based on the different cases in the decision table, you can ensure that the system behaves correctly for various combinations of conditions. This approach helps in covering multiple scenarios efficiently and ensures that the system's logic is considered and accurate

Use case testing:

Use case testing is a software testing technique that focuses on validating the interactions between users and a system by testing specific use cases or scenarios. Use cases represent real life interactions with the software and describe the steps users take to accomplish certain tasks

Example:
Let us consider an example of a simple online ordering system for a pizza restaurant, one of the key cases is 'place order'. The use case involves a user selecting pizzas, customizing them, adding them to the cart, and finally placing the order.

Use case: Place order

Scenario:

User browses the menu and selects two pizzas
User customizes the order by selecting toppings and specifying crust preferences.
User adds both pizzas to the cart.
User reviews the cart to ensure the correct items and qualities.
User proceeds to checkout and provides delivery details
User confirms the order
Some of test cases for use case testing:

Test case 1: successful order placement
Test case 2: empty cart check
Test case 3: customization and cart update
Test case 4: Invalid toppings
Test case 5: Delivery address validation
Test case 6: Order confirmation
By testing these different test cases that correspond to the specific use case, you can ensure that the 'place order' functionality of the online ordering system works correctly, provides a smooth user experience, and handles various scenarios effectively. Use can testing helps identify any issues related to user interactions and verifies that the system behaves as expected in real life scenarios

LCSAJ Testing

LCSAJ stands for Linear Code Sequence And Jump. The LCSAJ testing is a white-box testing testing that focuses on testing the linear code sequence and jumps within a program. It aims to ensure that every possible linear code sequence and jump is executed at least once during testing. LCSAJ testing helps in identifying potential issues related to program control flow, branching, and loop execution.

Example:

Consider a simple program. Let's calculate the factorial of a number using recursion:

Def factorial(n):
If n==0:
return 1
else:
return n*factorial(n-1)

In this example, there are several linear code sequence and jumps:

The sequence of statement in the 'factorial' function before the 'if' condition.
The jump from the 'if' condition to the 'return 1' statement.
The sequence of statements within the 'else' block.
The recursive jump to the 'factorial(n-1)' call.
Some of the LCSAJ test cases:

To perform LCSAJ testing on testing on this code, you would need to create test cases that cover all the identified linear code sequence and jumps

Test case 1: n= 0
*Test input: n=0
*Expected result: The function should return 1 without enterning the 'else' block.

Test case 2: n>0
*Test input: n=5
*Expected result: The function should return 1 without entering the 'else' block.

Test case 3: Negative n
*Test input: n= -3

Expected result: The function should handle negative inputs gracefully and return and appropriate result
By testing these specific test cases, you cover the different linear code sequence and jumps within the program. This approach helps in ensuring that all parts of the code are executed and the program's control flow behaves as expected. It's important to identify these sequences and jumps and create test cases that exercise them to achieve comprehensive coverage and identify potential issues in the control flow logic of the code.

Software Testing(Task - 1)

sankar — Wed, 10 Apr 2024 14:43:06 +0000

SOFTWARE TESTING

software testing
Verification is the process, to ensure that whether we are building the product right i.e., to verify the requirements which we have and to verify whether we are developing the product accordingly or not. Activities involved here are Inspections, Reviews, Walk-throughs
software testing
Validation is the process, whether we are building the right product i.e., to validate the product which we have developed is right or not.
Dynamic Testing
Dynamic testing involves the execution of code. It validates the output with the expected outcome
White Box Testing
White Box Testing is also called as Glass Box, Clear Box, and Structural Testing. It is based on applications internal code structure. In white-box testing, an internal perspective of the system, as well as programming skills, are used to design test cases
Box Testing
Black Box Testing is a software testing method in which testers evaluate the functionality of the software under test without looking at the internal code structure. This can be applied to every level of software testing such as Unit, Integration, System and Acceptance Testing. Click here for more details.
Grey Box Testing
Grey box is the combination of both White Box and Black Box Testing. The tester who works on this type of testing needs to have access to design documents. This helps to create better test cases in this process.
Positive and Negative Testing
Positive Testing: It is to determine what system supposed to do. It helps to check whether the application is justifying the requirements or not.
Negative Testing: It is to determine what system not supposed to do. It helps to find the defects from the software.
Test Strategy
Test Strategy is a high-level document (static document) and usually developed by the project manager. It is a document that captures the approach on how we go about testing the product and achieve the goals. It is normally derived from the Business Requirement Specification (BRS). Documents like Test Plan are prepared by keeping this document as a base.
Test Suite
Test Suite is a collection of test cases. The test cases which are intended to test an application.
Test Scenario
Test Scenario gives the idea of what we have to test. Test Scenario is like a high-level test case.
Test Case
Test cases are the set of positive and negative executable steps of a test scenario which has a set of pre-conditions, test data, expected result, post-conditions and actual results.
Test Data
Test data is the data that is used by the testers to run the test cases. Whilst running the test cases, testers need to enter some input data. To do so, testers prepare test data.
For example, To test a basic login functionality having a user id, password fields. We need to enter some data in the user id and password fields. So we need to collect some test data.
Test Closure
Test Closure is the note prepared before test team formally completes the testing process. This note contains the total no. of test cases, total no. of test cases executed, total no. of defects found, total no. of defects fixed, total no. of bugs not fixed, total no of bugs rejected etc.,
Test Report
A test report is a document that provides an overview of testing objectives, activities, and results. It is necessary to summarize testing results and compare them against expectations. It helps us determine if the product is ready for release or not. Additionally, it allows us to see the current status of the project and assess the quality of the product
What are the levels of testing?
In software testing, there are four testing levels.

Unit Testing or component level testing
Integration Testing
System Testing
Acceptance Testing Unit Testing Unit Testing is also called Module Testing or Component Testing. It is done to check whether the individual unit or module of the source code is working properly. It is done by the developers in the developer’s environment. Integration Testing Integration Testing is the process of testing the interface between the two software units. Integration testing is done in three ways. Big Bang Approach, Top-Down Approach, Bottom-Up Approach. System Testing Testing the fully integrated application to evaluate the system’s compliance with its specified requirements is called System Testing AKA End to End testing. Verifying the completed system to ensure that the application works as intended

Python selenium architecture and Virtual Environment:

sankar — Sat, 23 Mar 2024 15:47:47 +0000

Introduction to Selenium:

Automation:

Automation is a technology that is used to perform certain tasks with minimum or no human interactions or interference or efforts.

Selenium:

Selenium is an automation framework. It is an open source softwares (It is nothing but where the source code is distributed, making it available for using, modifying or distributing with it original rights. And it does not require any license to download or use it.)
It was created by Jasson Huggins in 2004. It was written in pure Java.
Selenium can be used with various other programming languages like Python, JavaScript, C#, Java, PHP and so on.
With selenium we can validate or verify the web applications.
Selenium is predominantly used in Automation Testing

Advantages of Selenium:

It is a open source framework
It can work with multiple operating systems like Windows, Mac, Linux / Unix
It works with different and multiple web browsers like Microsoft Edge, Chrome, Firefox, Safari, Opera etc.
You can integrate with any other testing framework like Pytest, Python Behave and so on along with Selenium
It uses less CPU and RAM during its working.

Disadvantages of Selenium:

It supports only web-based applications
You need to have a knowledge of Selenium to work with it as you need to know Python / Any programming language and the framework well. (The learning curve is hard)
You cannot automate CAPTCHA and SMS based OTP verification.
It has a small community so it lacks proper online support and due to this you need to put a lot of efforts to finding the solution to your problem
The program writing time is high.

Selenium Architecture

The architecture of Selenium is composed of:
Selenium IDE
IDE - Integrated Development Environment
It is just a web-browser extension that you need to download and install the extension for that particular web browser and start working with it.
One of the major advantages of using Selenium IDE is that it can automate and record the entire automation process as well
People generally do not use IDE, they rather prefer selenium scripts in order to do the same job.

Python Selenium architecture:

The Python Selenium architecture is composed of several components that work together to automate web browser interactions.

Python:

Python serves as the primary programming language for writing Selenium scripts. It provides a simple and readable syntax, making it accessible for both beginners and experienced developers.

Selenium WebDriver:

Selenium WebDriver is the core component of Selenium. It provides APIs for interacting with web browsers programmatically. WebDriver communicates with the browser using a browser-specific driver. For example, ChromeDriver for Google Chrome, GeckoDriver for Mozilla Firefox, etc.

Web Browser:

Selenium supports various web browsers such as Chrome, Firefox, Safari, Edge, etc. It allows users to automate interactions with these browsers, including navigation, form filling, clicking buttons, etc.
Browser Drivers:
Browser drivers act as intermediaries between Selenium WebDriver and the web browsers. They translate Selenium commands into browser-specific actions. Each browser requires its own driver. Selenium provides separate driver executables for different browsers.

Remote WebDriver:

Selenium also supports running tests on remote machines or Selenium Grids. Remote WebDriver allows you to execute Selenium tests on a different machine than where your code is running. This is useful for distributing tests across multiple environments or running tests in parallel.

Testing Frameworks:

While not strictly a part of Selenium's architecture, testing frameworks like pytest, unit test, or Behave are often used alongside Selenium for organizing and executing tests efficiently.

Selenium Locators:

Id
Class
Name
Tag Name
Link Text
XPATH

Selenium Architecture

Selenium Remote Control

It is an outdated and deprecated technology. We do not use it these days.
It has been replaced with WebDriver which is far more better and easy to use.

Selenium WebDriver:

It is the most important and major component of selenium architecture.
It provides a programming interface between the language and the web-browser.

Selenium Client Library:

It consists of language bindings or commands which you will be using to write in your automation scripts.
They are compatible with W3C protocols like HTTP, HTTPS, TCP, UDP etc
They are the wrappers which send the script commands to the network, for the execution into the web-browser.

Selenium API

It contains a set of rules and regulation which your Programming language (Python) used to communicate with the Selenium
It helps in automation without the need for the user to understand what is happening in the background.

JSON wire protocol

The commands that you write are converted into JSON which is then transmitted across the network or to your web-browser so that it can be executed.
The JSON data are sent to the client using the HTTP protocol
It is used by the browsers also

Browser Drivers

It acts as a bridge between the Selenium Script, Libraries and the browser.
It helps us to run the selenium commands on the web browser.
https://github.com/mozilla/geckodriver/releases/tag/v0.34.0
https://googlechromelabs.github.io/chrome-for-testing/
https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/?form=MA13LH

Selenium Grid:

It is used to run parallel test on multiple devices running same or different browsers and we could also simulate at different geographical locations.
We can run multiple test-cases simultaneously at the same time.
It uses the master-slave architecture.

Commands to install selenium and webdriver-manager:

pip install selenium
pip install webdriver-manager

Python Virtual Environment:

A Python virtual environment is a self-contained directory that contains a Python installation for a particular version of Python, as well as additional packages. It helps isolate project dependencies and avoids conflicts between different projects.

Here are some examples of its significance:

1.Dependency Management:

Virtual environments allow you to manage project dependencies separately. You can install specific versions of packages for each project without affecting the system-wide Python installation or other projects.

2.Reproducibility:

By encapsulating dependencies within a virtual environment, you ensure that other developers can replicate your project's environment easily. This enhances collaboration and reproducibility of results.

3.Version Control:

Including the virtual environment directory in version control (e.g., using a requirements.txt file) ensures that everyone working on the project uses the same set of dependencies. It simplifies deployment and avoids unexpected issues due to dependency discrepancies.

4.Isolation:

Virtual environments provide a sandboxed environment where you can experiment with different packages or versions without worrying about affecting other projects or the system-wide Python installation

Virtual Environment:

It is a tool which helps python Developers and testers to keep project dependencies and modules which are required for different projects separate and independent from each other.
With this we can manage our projects and their dependencies far more easily and efficiently.
This allows us to have multiple independent python environments on the same system without them interfering with each other.

Uses of Virtual Environments:
Isolation
Dependency Management

How to create virtual environments in Python

virtualenv:
Install the virtualenv package:
pip install virtualenv
Create the python virtual environment:
virtualenv
Select the virtual environment:
Click ctrl + shift + p and select Python: Select Interpreter

Other way of using pipenv using terminal:

Create the Virtual Environment by: pipenv - -python 3.12
Install the packages pipenv install selenium pipenv install webdriver_manager
Run the python file pipenv run python main.py

Virtual Environment for Python

What is Virtual Environment?
Virtual environments are particularly helpful if the program requires an individual environment, with a unique python version and specific module versions. It prevents package conflicts.
You can use virtualenv to create your isolated environment.

Why do you need a virtual environment?

The virtual environment is a way to keep the python configuration isolated from other projects.
One user has multiple virtual environments on a single computer, one for eahch project. Different libraries can be incorporated in each virtual environment.

virtual environment

How to create a virtual environment using Python3?

Step1:

Install Virtual Environment
pip3 install virtualenv
Collecting virtualenv
Downloading virtualenv-15.1.0-py2.py3-none-any.whl (1.8MB)
100% |████████████████████████████████| 1.8MB 367kB/s
Installing collected packages: virtualenv
Successfully installed virtualenv-15.1.0

Step2:

In python 3, you can use this command 'python3 –m venv /path/to/create/the/virtual/env'.

-bash-4.2$ python3 -m venv test_venv
-bash-4.2$ ls
test_venv
-bash-4.2$

Step3: Activate virtual environment

-bash-4.2$ source test_venv/bin/activate
(test_venv) -bash-4.2$

Step4: Install the required libraries, using pip

For the example below,we have used 'flask' library. Flask lets you build web apps, you can make all kinds of things or even plot

(test_venv) -bash-4.2$ pip3 install flask
Collecting flask
Downloading https://files.pythonhosted.org/packages/9b/93/628509b8d5dc749656a9641f4caf13540e2cdec85276964ff8f43bbb1d3b/Flask-1.1.1-py2.py3-none-any.whl (94kB)
100% |████████████████████████████████| 102kB 3.8MB/s
Collecting Jinja2>=2.10.1 (from flask)
Using cached https://files.pythonhosted.org/packages/1d/e7/fd8b501e7a6dfe492a433deb7b9d833d39ca74916fa8bc63dd1a4947a671/Jinja2-2.10.1-py2.py3-none-any.whl
Collecting click>=5.1 (from flask)
Using cached https://files.pythonhosted.org/packages/fa/37/45185cb5abbc30d7257104c434fe0b07e5a195a6847506c074527aa599ec/Click-7.0-py2.py3-none-any.whl
Collecting itsdangerous>=0.24 (from flask)
Using cached https://files.pythonhosted.org/packages/76/ae/44b03b253d6fade317f32c24d100b3b35c2239807046a4c953c7b89fa49e/itsdangerous-1.1.0-py2.py3-none-any.whl
Collecting Werkzeug>=0.15 (from flask)
Using cached https://files.pythonhosted.org/packages/ce/42/3aeda98f96e85fd26180534d36570e4d18108d62ae36f87694b476b83d6f/Werkzeug-0.16.0-py2.py3-none-any.whl
Collecting MarkupSafe>=0.23 (from Jinja2>=2.10.1->flask)
Using cached https://files.pythonhosted.org/packages/b2/5f/23e0023be6bb885d00ffbefad2942bc51a620328ee910f64abe5a8d18dd1/MarkupSafe-1.1.1-cp36-cp36m-manylinux1_x86_64.whl
Installing collected packages: MarkupSafe, Jinja2, click, itsdangerous, Werkzeug, flask
Successfully installed Jinja2-2.10.1 MarkupSafe-1.1.1 Werkzeug-0.16.0 click-7.0 flask-1.1.1 itsdangerous-1.1.0
(test_venv) -bash-4.2$

In Python, "env" or "environment" refers to the environment where a Python program runs. This environment includes environment variables, Python packages, and dependencies that are available when the program is executed.

In the context of software development, the use of a "virtual environment" is highly recommended to avoid dependency issues and configuration errors. A virtual environment is an isolated environment in which Python packages and other dependencies can be installed separately from the system's global environment. This allows developers to work on multiple projects with different dependencies without worrying about conflicts between them. Python provides tools such as virtualenv and venv to create and manage virtual environments.

Here are the steps to create and use a virtual environment using the built-in venv module in Python:

Make sure that Python is already installed on your computer. You can check this by running the command python --version in the terminal.

Open a terminal or command prompt and navigate to the directory where you want to create the virtual environment.

Run the command python3 -m venv myenv to create a new virtual environment named "myenv". You can replace "myenv" with any name you like.

Once the virtual environment is created, activate it by running the command source myenv/bin/activate on Linux or macOS, or myenv\Scripts\activate on Windows.

You should now see the name of your virtual environment in the command prompt or terminal, indicating that it is active.

Install any packages or dependencies that you need for your project using the pip package manager. For example, you can run pip install numpy to install the NumPy package.

When you're done working in the virtual environment, you can deactivate it by running the command deactivate.

By creating and using virtual environments, you can avoid conflicts between packages and dependencies, and ensure that your project works correctly regardless of the system environment.

What is Selenium? Why do we use selenium for Automation?

sankar — Sat, 23 Mar 2024 15:42:53 +0000

Introduction to Selenium:

Automation:

Automation is a technology that is used to perform certain tasks with minimum or no human interactions or interference or efforts.

Selenium:

Advantages of Selenium:

Disadvantages of Selenium:
It supports only web-based applications
You need to have a knowledge of Selenium to work with it as you need to know Python / Any programming language and the framework well. (The learning curve is hard)
You cannot automate CAPTCHA and SMS based OTP verification.
It has a small community so it lacks proper online support and due to this you need to put a lot of efforts to finding the solution to your problem
The program writing time is high.

Selenium Architecture

Selenium Remote Control
It is an outdated and deprecated technology. We do not use it these days.
It has been replaced with WebDriver which is far more better and easy to use.

Selenium WebDriver:
It is the most important and major component of selenium architecture.
It provides a programming interface between the language and the web-browser.
It is composed of:
Selenium Client Library:
It consists of language bindings or commands which you will be using to write in your automation scripts.
They are compatible with W3C protocols like HTTP, HTTPS, TCP, UDP etc
They are the wrappers which send the script commands to the network, for the execution into the web-browser.

Selenium API
It contains a set of rules and regulation which your Programming language (Python) used to communicate with the Selenium
It helps in automation without the need for the user to understand what is happening in the background.

JSON wire protocol
The commands that you write are converted into JSON which is then transmitted across the network or to your web-browser so that it can be executed.
The JSON data are sent to the client using the HTTP protocol
It is used by the browsers also

Browser Drivers
It acts as a bridge between the Selenium Script, Libraries and the browser.
It helps us to run the selenium commands on the web browser.
https://github.com/mozilla/geckodriver/releases/tag/v0.34.0
https://googlechromelabs.github.io/chrome-for-testing/
https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/?form=MA13LH

Browser:
All the web browser.

Selenium Grid:
It is used to run parallel test on multiple devices running same or different browsers and we could also simulate at different geographical locations.
We can run multiple test-cases simultaneously at the same time.
It uses the master-slave architecture.

PyCharm:
It is a popular IDE for python
https://www.jetbrains.com/pycharm/download/?section=windows

Commands to install selenium and webdriver-manager:

pip install selenium
pip install webdriver-manager

XPATH in Selenium:

XPATH is a selenium technique that is used to navigate through HTML Structure of a webpage. It is a syntax that allows us to find elements on a webpage using XML Path expression.

Syntax of XPath:

Xpath = //tagname[@attribute = ‘value’]

Types of XPath:

Absolute XPath:
Absolute Xpath refers to the direct way of finding an element. The major drawback of Absolute XPATH is that if there are any changes in the element’s path, then the XPATH will fail.
It starts from the tag.
It always begins with the single forward slash (/)
Syntax of the Absolute XPath will look like:

/html/body/header/nav/div/div/div[2]/div[1]/ul/li[2]/a

Relative XPath:

In case of relative xpath, the path begins from the middle of the HTML DOM structure. Here, the syntax starts with the double forward-slash (//) that states that the element can be searched anywhere on the webpage.
It helps us to avoid to write a long XPATH.
Syntax:

Xpath = //input[@id=”fname”]

Xpath = //*[@id="navbarDropdown"]/text

Functions in XPATH:

contains():
The xpath contains() is used if part of the value of any attribute changes dynamically. The function can navigate to the web elements with the partial text present.

//tag_name[contains(@attribute, ‘value of the attribute’)]

text():
This function is used to locate the element on a web page using the web element’s text value. This is mainly used for elements that contains text like p, a, label etc.

//tag_name[text() = “Text of the element”]

start-with()
This function is used to find the element in which the attribute value starts with some specific character or a sequence of characters. This once again can be useful in dynamic web pages.

//tagname[starts-with(@attribute, ‘first_part_of_the_attribute_value’)]

program to take string and return true if it is a palindrome,false otherwise

sankar — Thu, 28 Dec 2023 16:45:33 +0000

'''
program to take string and return true if it is a palindrome,false otherwise
'''
string ="rotator"
result=string[::-1]
if result == string:
print("true")
else:
print("false")

output:

true

program to take a string and returns the number unique characters in it

sankar — Thu, 28 Dec 2023 16:31:22 +0000

'''
program to take a string and returns the number unique characters in it
'''
string = "pythonpythonversion"
string2 = set(string)
print(string2)

Output:

{'y', 'o', 'p', 'e', 's', 'i', 't', 'r', 'h', 'n', 'v'}

#program to remove vowels from given string

sankar — Thu, 28 Dec 2023 16:25:32 +0000

string = "PrepInsta"

vowels = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
result = ""

for i in range(len(string)):
if string[i] not in vowels:
result = result + string[i]

print("\nAfter removing Vowels: ", result)

Output:

After removing Vowels: Prpnst

Program to create pyramid using 1 to 20 nos

sankar — Thu, 28 Dec 2023 10:41:34 +0000

def numpat(n):

num = 1

for i in range(0, n):

num = 1

#print(num, end=" ")


for j in range(0, i+1):

    print(num, end=" ")


    num = num + 1


print("\r")

Driver code

n = 20
numpat(n)

Output:

1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10 11 12
1 2 3 4 5 6 7 8 9 10 11 12 13
1 2 3 4 5 6 7 8 9 10 11 12 13 14
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

python program to count total no of vowels in the given string

sankar — Wed, 27 Dec 2023 11:44:12 +0000

python program to count total no of vowels in the given string "Guvi Geeks Network Private Limited"

string = "Guvi Geeks Network Private Limited"
vowels = 0
for i in string:
if i=='a' or i=='e' or i=='i' or i=='o' or i=='u' or i=='A' or i=='E' or i=='I' or i=='O' or i=='U':
vowels = vowels+1
print("Total no of vowels in given string = " , vowels)

Output:

Total no of vowels in given string = 12

what is software testing,what we need to about software testing,Relevance of software testing

sankar — Sat, 02 Dec 2023 13:22:02 +0000

Software Testing can be broadly classified into 3 types:

Functional Testing:

Functional testing is a type of software testing that validates the software systems against the functional requirements. It is performed to check whether the application is working as per the software’s functional requirements or not. Various types of functional testing are Unit testing, Integration testing, System testing, Smoke testing, and so on.

Non-functional Testing:

Non-functional testing is a type of software testing that checks the application for non-functional requirements like performance, scalability, portability, stress, etc. Various types of non-functional testing are Performance testing, Stress testing, Usability Testing, and so on.

Manual Testing:

Manual testing includes testing software manually, i.e., without using any automation tool or script. In this type, the tester takes over the role of an end-user and tests the software to identify any unexpected behavior or bug. There are different stages for manual testing such as unit testing, integration testing, system testing, and user acceptance testing. Testers use test plans, test cases, or test scenarios to test software to ensure the completeness of testing. Manual testing also includes exploratory testing, as testers explore the software to identify errors in it.

Automation Testing:

Automation testing, which is also known as Test Automation, is when the tester writes scripts and uses another software to test the product. This process involves the automation of a manual process. Automation Testing is used to re-run the test scenarios quickly and repeatedly, that were performed manually in manual testing.
Apart from regression testing, automation testing is also used to test the application from a load, performance, and stress point of view. It increases the test coverage, improves accuracy, and saves time and money when compared to manual testing.

Preparation:

Once you know what you have to do, you have to build the foundation for testing. This includes preparing the test environment, collecting test-cases, researching product features and test-cases. Gathering tools and techniques for testing and getting familiar with them should also be done here.

Execution:

This is when you actually run tests on the product. You execute test-cases and collect the results. Then you compare the results with the expected result and see if the product is working as expected or not. You make a note of all the successful and failed tests and test-cases.

Reporting:

This is the last phase of software testing where you have to document all your findings and submit it to the concerned personnel. Test-case failures are of most interest here. A proper and clear explanation of tests run and outputs should be mentioned.

For complex tests, steps to reproduce the error, screenshots, and whatever is helpful should be mentioned.

Two Ways to Test:

As we know, in the current age of machines, everything that involves manual effort is slowly automated. And the same thing is happening in the testing domain. There are two different ways of performing software testing—manual and automation.

Manual labor in any field requires a lot of time and effort. Manual testing is a process in which testers examine different features of an application. Here, the tester performs the process without using any tools or test scripts. Without using any automated tools, testers perform execution of different test cases. Finally, they generate a test report.

Quality assurance analysts test the software under development for bugs. They do so by writing scenarios in an excel file or QA tool and testing each scenario manually.

But in automated testing, testers use scripts for testing (thus automating the process). The pre-scripted tests run automatically to compare actual and expected outcomes. With test automation, when constant human intervention is not necessary, things like regression testing and execution of repetitive tasks don’t seem like much effort.

Relevance of software testing:

A definitive objective for a product owner is to give the best consumer loyalty. The reason why apps and software should be tested is to bring the best user experience possible. Being the best product in this immersed market will assist you with increasing reliable customers which will have incredible long haul impacts. When clients will have astounding client experience they will, point of fact, advise their companions, and word to mouth will cause it to publicize itself, yet this works the two different ways.