Software Testing Tutorial #11 - Levels in Software Testing

Summary

This tutorial explains the four key levels of software testing: unit testing, integration testing, system testing, and user acceptance testing (UAT). The speaker emphasizes the distinction between testing levels and types, guiding viewers through each stage. Unit testing focuses on individual components, integration testing assesses the combination of units, system testing evaluates the complete system, and UAT ensures the software meets user needs. The video also highlights the role of testers and developers in each phase and offers practical insights into real-world testing practices.

Takeaways

• 📊 Levels of testing and types of testing are distinct concepts, and it's important to differentiate between them.
• 🔢 There are four main levels of testing in software testing: Unit Testing, Integration Testing, System Testing, and User Acceptance Testing (UAT).
• 🧩 Unit Testing focuses on testing individual units or components of a software application, often done by developers or white-box testers.
• 🛠️ Unit Testing may involve tools like JUnit, and it typically tests each component in isolation with various input combinations.
• 🔗 Integration Testing verifies that individual units work together correctly once they are combined or integrated, typically handled by testers.
• 🌐 System Testing is conducted on the entire system to ensure that all integrated components function as expected, covering all major workflows.
• 🏗️ System Testing can be further divided into System Test (ST) for standalone systems and System Integration Test (SIT) for systems integrated with external components.
• ✅ User Acceptance Testing (UAT) is the final level of testing, where the software is validated by the actual users or business to check if it meets their requirements.
• 📦 UAT is crucial for determining whether the software is fit for use by the customer or end-users before final acceptance.
• 💡 A clear understanding of these four levels of testing is essential for planning test efforts effectively and answering interview questions.

Q & A

What is the difference between levels of testing and types of testing?

Levels of testing refer to the different stages in the testing process, such as unit testing, integration testing, system testing, and user acceptance testing, which are all part of the software development lifecycle. Types of testing, on the other hand, refer to the different approaches or techniques applied during testing, such as functional testing, regression testing, etc.

What are the four main levels of testing in software testing?

The four main levels of testing in software testing are: 1. Unit Testing, 2. Integration Testing, 3. System Testing, and 4. User Acceptance Testing (UAT).

What is unit testing, and who usually performs it?

Unit testing is the first level of testing, where individual components or units of a software application, like a login field, are tested in isolation to ensure they function correctly. It is typically performed by developers, though white-box testers can also conduct unit testing.

What is the primary focus of integration testing?

Integration testing focuses on testing the interactions between individual units or modules once they have been combined. The goal is to ensure that the units work together as expected, testing scenarios like valid username/password combinations in a login page.

How does system testing differ from integration testing?

System testing is a broader form of testing where the entire system, including all integrated modules, is tested as a whole to ensure it meets the functional and non-functional requirements. In contrast, integration testing focuses on testing the interaction between specific integrated components.

What is the difference between system testing (ST) and system integration testing (SIT)?

System testing (ST) tests the entire software as a standalone product without any external dependencies. System integration testing (SIT) is conducted when the software integrates with external systems to ensure that the external interfaces function correctly.

What role does the user play in user acceptance testing (UAT)?

In user acceptance testing (UAT), the users or customers test the software to ensure it meets their needs and expectations. UAT ensures that the software is fit for use and addresses real-world requirements before it is accepted for deployment.

Who is responsible for performing integration testing?

Integration testing is primarily the responsibility of the testing team. They verify that the individual components or modules interact as expected after integration.

Why is understanding the levels of testing important for testers?

Understanding the levels of testing helps testers organize and structure their testing efforts according to the software development cycle. It ensures that they are applying the right testing techniques at the appropriate stage to find issues effectively.

Can system testing involve external systems? If so, how?

Yes, system testing can involve external systems, in which case it is referred to as system integration testing (SIT). This phase tests the software’s interaction with external systems to ensure compatibility and proper communication between different systems.

Outlines

00:00

🔍 Introduction to Levels of Testing

The introduction distinguishes between levels and types of testing. It emphasizes the importance of understanding the difference, as they are often confused. The focus of the tutorial is on the four levels of testing in software development, starting with unit testing, which will be discussed first. The detailed explanation of types of testing will follow in later tutorials.

05:02

🛠️ Unit Testing Overview

Unit testing is the first level of testing. This section explains how developers test individual components (units) of an application, such as a login page's username and password fields. Unit testing ensures each component functions correctly before integration. Most unit testing is done by developers using tools like JUnit, but testers with white-box testing skills may also conduct unit testing.

10:02

🔗 Integration Testing Explained

This part covers integration testing, the second level of testing. After individual units are tested, they are combined into modules, such as a complete login page. The integrated components are tested together to ensure they work as a cohesive unit. Integration testing is typically the responsibility of the testing team, and they check for functionality, business logic, and combinations like valid or invalid username/password entries.

🖥️ System Testing and SIT

System testing, the third level of testing, is categorized into System Testing (ST) and System Integration Testing (SIT), depending on whether the software integrates with external systems. This phase ensures that the entire application works as intended, from login to checkout, and covers end-to-end functionality. SIT is essential for complex systems that rely on external integrations, such as banking or ecommerce applications.

👥 User Acceptance Testing (UAT)

The final level of testing is User Acceptance Testing (UAT). This testing is conducted by the business or customer to verify that the software meets their needs and requirements. The end user evaluates the software to determine if it is ready for release, ensuring the product delivers the expected value. Any defects or mismatches are reported back for resolution before final acceptance.

💡 Importance of Understanding Testing Levels

The conclusion emphasizes the importance of understanding the four levels of testing for both practical application in the industry and for interview preparation. It highlights how knowing these levels helps testers plan and execute their testing efforts based on the development cycle and system complexity. The distinction between system testing and SIT is especially important for complex software.

Keywords

💡Levels of Testing

Levels of Testing refer to the different stages in the software testing lifecycle where tests are conducted. These stages ensure the software is thoroughly tested before release. In the video, four levels of testing are introduced: Unit Testing, Integration Testing, System Testing, and User Acceptance Testing. Each stage plays a crucial role in validating different aspects of the software.

💡Unit Testing

Unit Testing is the first level of testing, focusing on individual components or units of the software. Developers usually perform this testing to ensure that each unit works as intended. In the example of the login page in the video, the username and password fields are tested individually to confirm they meet the functional requirements, like limiting the username to a certain number of characters.

💡Integration Testing

Integration Testing is the second level of testing, where individual units are combined and tested as a group to ensure they work together. In the context of the video, once the login page components, like username, password, and login button, are built and tested individually, they are integrated to see if the page functions correctly when the parts interact with each other.

💡System Testing

System Testing is the third level of testing, where the complete and integrated software is tested to verify it meets the specified requirements. In the video, this involves testing the entire ecommerce website, such as logging in, adding items to a cart, and making payments, to ensure that all modules work cohesively.

💡User Acceptance Testing (UAT)

User Acceptance Testing (UAT) is the final level of testing, conducted by the customer or end-users to determine if the software meets their needs and requirements. It serves as the final validation before release. In the video, UAT is explained as the phase where real users test the software to decide if they will accept or reject it based on how well it aligns with their expectations.

💡White Box Testing

White Box Testing is a testing technique where the tester knows the internal structure and design of the software. In the video, it is mentioned that developers or white box testers may conduct Unit Testing by directly testing the code and the logic behind individual components.

💡JUnit

JUnit is a widely-used framework for performing Unit Testing in Java. It allows developers to write repeatable tests for their code. The video uses JUnit as an example of a tool that could be used to test small units like the username field in the login page to ensure it works properly.

💡System Integration Testing (SIT)

System Integration Testing (SIT) is a specialized form of system testing that focuses on testing the interactions between the system being developed and external systems. In the video, SIT is mentioned as necessary when the software integrates with third-party systems, like a banking application integrating with an external card provider.

💡Business Logic

Business Logic refers to the rules and operations that govern how the software behaves in real-world scenarios. In the video, business logic is applied to components like the login page, where valid usernames and passwords must meet certain criteria for the user to log in successfully.

💡Test Environment

A Test Environment is the setup in which testing is performed, consisting of hardware, software, and configuration settings. In the video, it's highlighted that knowing the levels of testing helps testers create appropriate test cases and execute them in a proper test environment, ensuring the software functions as expected in the real world.

Highlights

Clarification between levels and types of testing: Levels of testing are distinct from types of testing, which is crucial for understanding software testing concepts.

Four key levels of testing: Unit Testing, Integration Testing, System Testing, and User Acceptance Testing.

Unit Testing explained: Involves testing individual components or units of code, like a username or password field, typically done by developers or white-box testers.

Unit Testing is also called component testing and focuses on individual code components being tested in isolation.

Integration Testing: Ensures that individual components work together as an integrated module, such as a complete login page that includes username, password, and login button.

Integration Testing responsibilities: Usually carried out by the testing team to validate that different modules interact correctly.

System Testing: Involves testing the entire software system, ensuring all modules are integrated and work as expected, covering the complete functionality of the system.

System Testing phases: System Testing can be split into ST (System Test) and SIT (System Integration Test), depending on the software complexity and external system integrations.

System Integration Testing: SIT is required when the software interacts with external systems, such as third-party services, and involves testing the integrated system as a whole.

User Acceptance Testing (UAT): Involves real users or business stakeholders testing the software to ensure it meets their requirements and is fit for use.

Purpose of UAT: The user decides whether the software is acceptable or if any issues need fixing before it is fully deployed.

Importance of understanding levels of testing: Knowing the levels helps testers plan and execute the appropriate test cases at each phase of the software development cycle.

Integration Testing example: Testing the login page's functionality, ensuring a valid username and password allow login while invalid combinations are correctly handled.

System Testing example: Testing an entire e-commerce platform's functionality, from login to checkout and payment processing, ensuring everything works as a unified system.

Distinction between ST and SIT: In complex systems, both system testing (ST) and system integration testing (SIT) are necessary to ensure smooth operation across internal and external integrations.

Transcripts

hello everyone welcome again in the

software testing tutorial

we are going to learn levels of testing

now do not confuse levels of testing

with types of testing

so this is very very important to

understand the segregation between

levels of testing and

types of testing right so when somebody

asks the level of testing

or levels of testing in software testing

then that's a different

thing and types of testing there are

many types of testing so first

let's understand about the levels of

testing and then we'll go

into the details of the type of testing

in later tutorials

so when we talk about the levels of

testing there are mainly four

levels of testing in software testing

okay so that's the

important thing to remember four levels

of testing

and all the types of testing can be fit

within those four

levels right so the first level of

testing is

unit testing all right so unit

testing

so what happens in unit testing so say

for example

you are building the ecommerce

application

right so ecommerce application will have

a lot of functionalities

so we'll take a login page example which

is the simplest to

explain and understand right so login

page will have

the username and password fields and

the login button so in that particular

case when

some developer starts developing that

login page functionality

or the login functionality so if he is a

ui developer's what

he will work on is in work on the first

page

and that page will have

this login username and password

and the login button right so

when he works on this username and

password

field there will be some you know

restrictions or

limitation or requirements basically in

terms of username and password say

username cannot be more than you know

50 character or 100 characters password

should should have you know a special

character and

those sort of rules might be there right

just just for the sake of example i'm

taking these

so when he works on the code and he

creates

these username and password field you

can think of these

as a small units right or the

um you know component so unit testing is

also known as component testing so

these can be you know components or the

units

that can be tested separately because

there is

a underlying code that the developer

develops

in order to make them visible on the

screen

as well as if there is any logic that

needs to be built for these units

he needs to build that as well now once

these

in standalone units are built okay

so for example username he wrote the

code

and he also implemented the logic that's

a standalone unit of component

that he has built and then he will be

adding that to the overall

page right so when a

developer is testing this particular

unit that is known as

unit testing or unit as a standalone

just say for example

is testing the only username field with

different combinations

most of the time um it is the unit

testing will be done by developers

themselves

but if you are a white box tester who

who does unit testing then you might be

asked to do unit testing as well

so in that case that particular unit

whatever has been developed say for

example username field will be

tested through unit testing tool for

example you know junit

uh is is widely used in java development

with all different combinations and

whatever logic has been built

for that particular unit or the username

field similarly will be done for the

password

right any other field that is there on

the page

that will be tested accordingly so

that's what unit testing is all about

okay so that's the first level of

testing

when developer develops those units or

components

he tests or she tests those first

all right and the next

phase is integration

okay so integration

testing now what happens in integration

testing so units are built

okay so on the page you have

the units built so username field is

there password field is there

and the login button is there okay so

once all these smaller units have been

tested

and integrated so basically they are

integrated together into one module

or one you know piece so this page will

be visible which

which will have username and password

and login button okay

so this becomes your integrated page or

integrated page with

all the units that need to be there on

the page with

any business logic say for example valid

username valid password

and i click on login it should show me

the login successful

message and login should happen

successfully right

so in the integration what developer

does is they they

integrate the units that they have

developed into one

code or logical code that will display

this particular page in our example

and integration testing will be done

by the person who will be launching this

particular

page and then he'll try to test through

various combination of

username and password so valid username

valid password

uh he'll try to log in valid username

invalid password so all those

combinations

and the business rules that have been

implemented on this

integrated whole piece or page

that will be tested right so this is

what integration

testing is all about and how integra

integration testing will be done

for the login page okay so

this integration testing will be mostly

done by the testing team

most of the time i mean this is the

testing team's responsibility or the

tester's responsibility

unit testing could be developer could be

tester

okay so it depends if you're a white box

tester you will do it if you're

you know not a white box tester

then development team will do it but

integration testing is the testing

team's responsibility and if you're

working in the testing team

or a tester you will do the integration

testing of the modules that are being

deployed

right so that's what integration testing

is and that's the next level of testing

the third level of testing is system

testing

okay so system test

now in the system test what happens is

system test you can categorize into two

mostly right so system test

you can say st and then there is another

one which is

sit which is very you know popular

so you need to understand what is the

difference between system test and

system integrated test

but within system test these are the two

phases that

can be possible depending on how complex

your software

is so in the system test what happens is

so in the integration testing say for

example you just verified

the integrated login page which has

username and password and login button

right so that's one integrated model

that you verified now in the system test

the overall software or the overall

ecommerce website when it is developed

so you have the login page once you log

in

you add the items to cart you remove the

item from the cart

you go to the checkout page you make the

payment and

all things work successfully right so

when all the modules are built and

integrated

as a system or a system as a whole then

that's what

system testing is all about okay so once

everything in the software is ready and

deployed

then that's when system testing starts

and this is also done by the

testing team now system testing can have

a system test phase

if your software is a standalone

software or it doesn't integrate with

any of the external

systems right so say for example you

have a

software that runs on a standalone

machine and doesn't integrate with any

other

you know machine or softwares okay so

that

is what will be done as a system tester

for example you have the

microsoft word document is a standalone

software

when you test that that system testing

phase will just have the sd phase system

test phase

but say for example you are working in

the banking application

so banking application might have

integration

with external systems as well so for

example when i

apply for the card then after

application of the card when card

is received or card is being embossed

and sent to me

uh that is done by the third party

you know vendor it might be possible it

is done by a third party vendor

who send me the physical card or the

chip right

so when that's the case when my software

say for example my software here is

integrating with some of the external

systems as well then i have to do

sit as well system integration testing

okay

so in that case this is not a standalone

software that runs on my machine so that

is why

in system test phase there will be st

and sit

both if your software or application

integrates with external

systems i'll explain these two in a lot

more detail with real example

in upcoming tutorials so don't worry

about those in

detail at the moment so this is the next

level of testing so system testing is

the next level of testing

now the fourth level of testing is

user acceptance

testing all right

now what happens in uh user acceptance

testing or the acceptance testing

uh i'll say um so

in the acceptance testing what usually

happens

is when the software is being built

the acceptance testing is mostly done by

the business

okay by the business or by the customer

the real

consumer who will be using the software

so in the acceptance testing

it is mostly seen whether the software

that has been built

is fit for use or whether it provides

the real value

or it provides the functionality that

the customer

is looking for and that is why this is

called as

uat user acceptance testing in short it

is called uat

and user acceptance testing because user

who is the user of the software will be

testing it and whether

he'll you know accept it or reject it or

he'll raise the defect that this is not

what i was looking for

and then the team needs to fix those

or make sure that the software that has

been developed

meets the actual user requirement right

so this is the

next phase of or the level

of testing right so these are

the four levels of testing that you need

to remember

for any interview purpose or

for getting into you know even if you're

working in the software testing field

you need to thoroughly understand these

levels because

when you understand these levels you

will be able to understand

how you are going to segregate your

testing effort

uh based on the development cycle and

when the

the delivery or the code is being

deployed into the

into the test environment you will be

able to write the relevant test cases

and test accordingly when you have the

knowledge of

levels of testing and what what you need

to do in each

level of testing right so this is about

the level of testing

very important aspect is the system test

it can have

just system testing or it can have a

combination of system test

followed by system integration testing

srt as well right

so this is what we do

practically in the industry so there are

a lot of bookish

knowledge out there which just says you

know there are four levels

and system test is one of the level but

you need to ensure or you need to

understand that system testing

is divided you know the broader

application is just system test but

internally in within the system test

that could be system test

or st and sit both depending on which

type of software you are testing all

right so that's all for

this tutorial on levels of testing hope

this was helpful and will help you in

your interview

um you know questions to answer all the

queries if you get any queries on the

levels of testing

thank you very much for watching please

do share and subscribe

thank you