Things need to know about software testing

In this ultimate guide to software testing, we will cover the following:

1. Types of testing:

→Manual testing: Testers manually execute test cases without automation tools.

→Automated testing: Uses tools and scripts to automatically run test cases, increasing efficiency, especially for repetitive tasks.

2. Testing approaches:

→White Box testing: White box testing involves testing the software’s internal structure, design, and coding. In white box testing, the tester has complete visibility of the source code and uses this knowledge to design test cases. The main focus is on the logical flow of the software, code structure, conditions, paths, and branches.

→Black Box testing: Black box testing focuses on the software’s functionality without considering its internal code structure. The tester is unaware of the internal workings of the application and tests the software by checking its inputs and outputs. The primary focus is on the software’s functionality, behavior, and requirements.

→Grey Box testing: Grey box testing is called that because it’s seen as a middle ground between the “white” (clear, open to view) and the “black” (opaque, closed to view) testing methodologies. This approach provides a more comprehensive testing perspective by considering both the software’s internal workings and external functionality.

3. Functional vs. Non-Functional testing:

→Functional testing: This type assesses the quality, features, and functionality of the software code. It aims to verify that each function of the software application operates per the specified requirements.

→Non-Functional testing: This type focuses on the software application’s performance and quality in real-world scenarios. It includes testing aspects like performance, scalability, reliability, and usability, which are not directly related to specific behaviors or functions of the system.

4. Stages of testing:

→Unit testing: Unit testing is testing individual units or components of an application. The aim is to ensure that each unit performs as designed. It is typically carried out by developers rather than the quality assurance team, as it requires a detailed knowledge of the internal program design and source code and belongs to the White box approach.

→Integration testing: Integration testing usually follows unit testing (where individual components are tested in isolation). After units are individually tested, they are gradually aggregated and tested together in a process that can be incremental or all at once, depending on the testing strategy.

→System testing: System testing typically employs a black-box testing approach, where the tester does not need to know the internal workings of the software. The focus is on input and output and the system’s functionality. It is usually performed in an environment that resembles the production environment to simulate real-world conditions as closely as possible.

→Acceptance testing: Acceptance testing is a critical phase in the software development lifecycle, primarily focused on determining whether the software meets the end user’s needs and requirements. It’s the final testing stage before the software is deployed. The client or end-users typically conduct this type of testing, sometimes called User Acceptance Testing (UAT).

Relevance of software testing

1. Customer Satisfaction: The prime goal of any service-based organization is to serve the best features and experience to their customers, customer satisfaction is the only goal for the success and popularity of an application.

• Software testing helps in building the trust and satisfaction of the customer by assuring a defect-free application.
• UI testing enhances customer satisfaction. Software Testing tries to uncover all possible defects and test an application as per customer requirements.
• For example, eCommerce is dependent on the customer, and a satisfied customer will improve its market value and earnings.

2. Cost Effective: If an application works without any fault and with low maintenance will save a big amount for the owner.

• Software testing helps in early defect detection and fixing them to make a more successful and good return application.
• Every application demands maintenance and the application owner spends a good amount to maintain the working and functionality of the application.
• By testing an application, the maintenance area reduces too many folds and hence saves money.
• Software testing helps in saving the money of the developing organization by detecting defects in the early stages of the software which becomes easy and economical for the developer to redesign the module instead of detecting bugs after the complete development of the software.

3. Quality Product: The main focus of software testing is to deliver a quality product to its clients which results in a satisfied client. The quality of a product can only be maintained when it is bug-free and meet all the user requirements.

• To meet the product qualities, if an application works with other related applications then it must undergo compatibility testing.
• During software testing, an application undergoes several testing techniques to make a quality end product and the testing team tries their best by writing test cases and test scenarios to validate defect-free free applications.

4. Low Failure: Failure of an application impacts its working and brand value. Software testing helps in knowing the cases where a particular application is most likely to fail.

• For example, An eCommerce application is more likely to fail when there is heavy traffic and load.
• This type of application goes through stress testing to check the highest possible limit of the application to handle the load.
• Software testing makes an application more robust and reliable.

5. Bug-Free Application: The main task of software testing is to identify bugs and inform them the concerned developing team to fix. When a bug is fixed, testers recheck the bug to identify its status.

• A bug-free application means an application with no glitches, faults, or defects and works effectively and smoothly. The only demand of an application is that it functions as per requirements and does not behave unusually due to defects.
• A 100% bug-free application is practically not possible but the testing team tries to identify as many as possible bugs in the application by creating test scenarios. Software testing follows the STLC process to detect a bug.

This wire protocol represents a RESTful web service using JSON over HTTP. In Selenium, the Selenium WebDriver architecture consists of four major components:

Selenium Client Libraries
JSON Wire Protocol
Browser Drivers
Real Browsers

Selenium Client Libraries:

Selenium supports multiple libraries such as Java, Ruby, Python, etc. Selenium Developers have developed language bindings to allow Selenium to support multiple languages. These are language-specific libraries that allow interaction with the Selenium server. The client libraries provide bindings to different programming languages (Java, Python, C#, etc.) and enable developers to write test scripts.

JSON Wire Protocol:

Selenium 3 initially used the JSON Wire Protocol for communication between the client libraries and the WebDriver. This protocol defined a RESTful API over HTTP and served as a bridge to execute commands on the browser. JSON Wire prototype over HTTP Client JSON stands for JavaScript Object Notation. It is used to transfer data between a server and a client on the web. JSON Wire Protocol is a REST API that transfers the information between HTTP server.

Browser Drivers:

Each browser contains a separate browser driver. Browser drivers communicate with the respective browser without revealing the internal logic of the browser’s functionality. When a browser driver has received any command then that command will be executed on the respective browser and the response will go back in the form of an HTTP response.

Browser drivers are separate executables responsible for establishing a connection between the Selenium WebDriver and specific web browsers (Chrome, Firefox, Edge, etc.). Each browser has its driver (e.g., ChromeDriver, EdgeDriver) that translates WebDriver commands into actions understood by the browser.

Selenium WebDriver:

This component directly communicates with the browser drivers. It provides an API for various browser automation commands like opening a browser, navigating to URLs, interacting with web elements, etc.

Browsers

Selenium supports multiple browsers such as Firefox, Chrome, IE, Safari, etc.

What is the significance of the python virtual environment? Give some examples

Virtual environments used to Python developers by offering controlled, reproducible, and isolated environments for their projects, facilitating smoother development, testing, collaboration, and deployment processes. To create a virtual environment in Python, you typically use tools like venv or virtualenv. Once created, you activate the environment and install necessary packages specific to the project within that isolated space.

This way, you maintain control over dependencies and ensure a smooth development and deployment process for your Python projects. Python virtual environments are crucial for several reasons:

Project Isolation:

They provide isolated environments for Python projects. Each virtual environment has its own set of libraries and dependencies, allowing different projects to have their specific versions of packages without conflicts. This isolation ensures that changes made in one project don’t affect others.

Let’s Consider we’re working on two different Python projects, one using Django 2.1 and another using Django 3.0. Virtual environments allow you to create isolated environments for each project. For instance:

Example:

Project A: You create a virtual environment with Django 2.1 installed (django==2.1)
Project B: You create another virtual environment with Django 3.0 (django==3.0)
This isolation prevents conflicts between different versions of the same package required by different projects.

Dependency Management:

Virtual environments help manage dependencies by allowing you to install specific versions of libraries for each project.This prevents version clashes and ensures that the project runs consistently across different environments.

Let’s say we’re developing a web application that uses specific versions of libraries. With virtual environments, you can ensure the exact versions are installed:

Example:

Project X requires requests==2.25.0 and numpy==1.21.2.
Project Y needs requests==2.24.0 and numpy==1.20.3.
By creating separate virtual environments for each project, you can maintain these specific versions without interference.

Ease of Collaboration:

When working on a project with multiple developers, virtual environments make it easier to share code. By sharing the project along with its virtual environment configuration (often stored in a requirements.txt file), collaborators can easily replicate the environment and start working without worrying about conflicting dependencies.

Security:

Using separate environments can enhance security by limiting access to specific resources and libraries. If one project encounters a security issue, it won’t necessarily affect other projects in different environments.

Testing and Stability:

Virtual environments facilitate testing and stability. They ensure that a project works reliably by isolating its dependencies. Testing in a controlled environment helps catch issues related to dependencies or compatibility.

Testing and Deployment:

Virtual environments play a crucial role in testing. For instance, you want to test your web application in a controlled environment. You create a virtual environment, install required packages, run tests, and ensure it works flawlessly. When deploying the application to a server or another machine, you replicate the same environment using the requirements.txt file, ensuring consistency.

Upgradability and Reproducibility:

With virtual environments, you can upgrade or change dependencies for a specific project without affecting other projects.Moreover, these environments allow you to reproduce the exact environment used during development, making it easier to deploy the project in different settings.

Collaboration and Reproduction:

Imagine we are collaborating on a data science project. You can share the code along with a requirements.txt file that lists all the dependencies. Colleagues can create a virtual environment using this file (pip install -r requirements.txt) to reproduce the exact environment you used for development.

Cleaner Development:

Virtual environments help keep the system’s global Python environment clean. They prevent the installation of unnecessary packages globally, reducing the risk of conflicts and keeping the global environment tidy. Avoiding Global Package Conflicts:

Consider a scenario where you’re experimenting with different machine learning libraries. Instead of installing all these libraries globally, potentially causing conflicts, you create separate virtual environments for TensorFlow, PyTorch, and Scikit-learn experiments. This segregation prevents clashes and maintains a clean global Python installation.

Things of selenium

Selenium is an automation testing tool for web applications for testing purposes across different browsers, platforms, and programming language and it is an open source tool. It is a testing tool was developed by Jason Huggins in 2004, To control browser actions automatically “JavaScript TestRunner” is developed and then this JavaScript program renamed as Selenium.

Selenium is used for testing of web applications, we can neither test any desktop application nor mobile application. Scripts can be written in Java, Python, C#, PHP, Ruby, Perl, and .Net programming languages. Selenium work at Windows, Linux and Mac operating system.

Selenium can be integrated with tools such as TestNG & JUnit for managing test and generating the report or Maven, Jenkins & Docker for Continuous Testing.

Selenium uses in Automation

Selenium is the core technology in browser automation tools, APIs and frameworks. It is quite similar to HP Quick Test Pro. Selenium code is tested on Google Chrome, Mozilla Firefox, Internet Explorer, Safari and Opera browsers. Selenium allows recording, editing, and debugging tests.

Automation testing aims to improve testing efficiency, accuracy, and speed by automating repetitive and time-consuming manual testing tasks. Automation testing or test automation uses open source or paid automated testing tools to test software applications quickly and efficiently, and 24/7 without human intervention.

Selenium WebDriver tool is used to automate web application testing to verify that it works as expected. It supports many browsers such as Firefox, Chrome, IE, and Safari. However, using the Selenium WebDriver, we can automate testing for web applications only.

Language Support: Selenium allows you to create test scripts in different languages like Ruby, Java, PHP, Perl, Python, JavaScript, and C#, among others.

Browser Support: Selenium enables you to test your website on different browsers such as Google Chrome, Mozilla Firefox, Microsoft Edge, Safari, Internet Explorer (IE), etc.

Scalability: Automated testing with Selenium can easily scale to cover a wide range of test cases, scenarios, and user interactions. This scalability ensures maximum test coverage of the application’s functionality.

Reusable Test Scripts: Selenium allows testers to create reusable test scripts that can be used across different test cases and projects. This reusability saves time and effort in test script creation and maintenance.

Parallel Testing: Selenium supports parallel test execution, allowing multiple tests to run concurrently. This helps reduce the overall testing time, making the development process more efficient.

Documentation and Reporting: Selenium provides detailed test execution logs and reports, making it easier to track test results and identify areas that require attention.

User Experience Testing: Selenium can simulate user interactions and behavior, allowing testers to assess the user experience and ensure that the application is intuitive and user-friendly.

Continuous Integration and Continuous Deployment (CI/CD): Selenium can be integrated into CI/CD pipelines to automate the testing of each code change. This integration helps identify and address issues earlier in the development cycle, allowing for faster and more reliable releases.

Software Testing is a method to check whether the actual software product matches expected requirements and to ensure that software did not have any errors or defects. To execute the software testing we need two type of testing Manual Testing and Automation Testing.

What is manual Testing

Manual Testing is the process of testing the software manually. It can be done by the software tester. It requires proper knowledge and moreover patience to detect the bugs and figure out the errors. But it takes a lot of human efforts to develop this much needed software. For developing software and programs a person must have proper knowledge about programming languages and it cannot be done by every individual.

Advantages of Manual Testing

Uses human intelligence to find the errors: Manual testing allows testers to use their higher cognitive abilities, such as deductive reasoning and common sense when detecting software defects. This helps them find errors that automated tests might miss. That is also the main reason why you will always need a human to review the tests made by automated testing tools.

Tester knowledge of the project: Manual testing allows testers to monitor the quality of a product throughout its development cycle by spending more time familiarizing themselves with its features and functions. This helps maintain their knowledge of the project which will be useful if issues arise after changes have been made to the code.

Maintain a Testable System: Manual testing can help testers use their expertise in detecting bugs that could cause an application to become untestable because automated tests cannot test the system.

Disadvantages of Manual Testing

usability of Test Cases: Manual testing is more time consuming, it requires more time to write test cases and for test execution. Manual testing is little bit complex process. If the software application is complex, manual testing could take more time and more testers

Human Error while Testing: Human errors can happen when testing is done manually by testers. Testing particular scenarios testers may come up with errors. These mistakes done by testers should affect the quality of the software. Sometimes testers not sufficient to cover all the test cases it will give the less quality software to the customer.

Time consuming process: For testing so many test Case using manual testing was such difficult to do that. If a project has many test case it will take too much of time to complete compare to automation testing.

Real time example for Manual Testing

A simple example of testing would be a Login screen we could test quite a few scenarios.

1) Checking if Both Username and Password are entered and not blank
2) Masking of Password is implemented
3) Verifying if screen navigates to next page incase valid Login credentials are provided.
4) In Case of invalid login, ensuring system does not navigate further but displays an error message.
5) Checking the maximum possible length of login and password fields.

Functional Testing

• It works as per the requirements and functionality of the application
• This type of functional testing works as per the customer needs
• This type of the testing show what the software behave as per the requirements provided by the customer
• Types: Unit testing, integration testing, acceptance testing, System testing

Example:

→ Giving sample inputs and check or verify whether the actual output is coming or not.

→ logging into a webpage with the correct username and password

Non Functional Testing

• This type of testing is only used to check how the software is behave and perform
• No functional testing is used to improve the quality of the product as per customer requirements
• Types: performance testing, load testing, security testing, volume testing, portability testing.

Example:

→ checking the overall performance of the product

→ Check how many users can use the website with stress testing.

Boundary value testing is one technique of testing used to evaluating the data based testing with the help of minimum and maximum value of the data given

Example: if we put maximum discount of the product should be 10% to 15%

• TC1 → 0% given as invalid
• TC2 →9.99% given as invalid
• TC3 → 10% given as valid
• TC4 →15% given as valid
• TC5 → 15.01% given as invalid

Decision table Testing

Decision Table Testing is technique which can be used to work as a systematic input given by the uses and represented with the behavior of the output as per the Tabular format

Example : Entering the user name and password for the log in page

• TC1 → correct user name and correct password result must be Successful
• TC2 →correct user name and incorrect password result must be invalid password
• TC3 →incorrect user name and correct password result must be invalid user name
• TC4 → incorrect user name and incorrect password result must be account not registered

Use Case Testing

Use case testing is a functional testing which can be identify with the test scenarios on the whole system by the system and actor method

Example: Test case for the vending machine

actor and system interaction are the source for the testing

LCSAJ Testing

An LCSAJ is a Linear Code Sequence and Jump linear. Each LCSAJ commences either from the start of the program or from a point to which control flow may jump. Part of the code executed in straight line without any jump. LCSAJ is a white box testing method that requires access to the source code, and presents results with reference to that source code.

LCSAJ testing is useful for ensuring through code coverage, which is essential for identifying potential defects in the code. It helps developers and testers gain confidence that the code has been tested comprehensively and that critical control flow paths have been examine.

• software testing is the process of testing whether the software was functioning properly or not.
• need to check the quality of the product and ensure the value of the product to the customer

Thing need to know about the software testing

• In software testing, tester is important to check the developed product and tester is responsible for the quality of the product

relevance of software testing

• Identify the errors and bugs to improve the quality of the product
• To find the defects of the software in early stage and correct it.