Software Testing Tutorial #9 - V Model in Software Engineering

Summary

This tutorial introduces the V-Model, an improvement over the Waterfall model in software development. It addresses the delay in testing in the Waterfall approach by involving the testing team at every stage of the development process. The video explains how the V-Model aligns testing phases with corresponding development phases, such as writing test cases during requirements gathering and system design. This early involvement of testers helps identify defects earlier, ensuring better quality and feedback throughout the lifecycle. The tutorial also highlights the advantages of the V-Model over the Waterfall model.

Takeaways

• 📋 V-Model is an improvement over the Waterfall Model, addressing its major drawback: delayed feedback in testing.
• ⏳ The main issue with the Waterfall Model was the late involvement of testing, leading to delayed defect detection.
• 💡 In the V-Model, testing is incorporated at every phase, with corresponding test phases for each development phase.
• 📝 During the requirements gathering phase, the testing team starts writing user acceptance test cases to catch defects early.
• 🔍 The system analysis and design phase involves understanding how the new system will interact with other systems, while testers write system test cases for end-to-end testing.
• ⚙️ In the global design phase, the testing team prepares integration test cases to ensure modules work together after coding.
• 🧩 During the detailed design phase, testers create unit test cases for individual modules. These are often written by developers but might involve white-box testers.
• 👨‍💻 The coding phase begins once the design is complete, and testing execution starts immediately for unit tests and integration tests as modules are developed.
• 🌐 Integration testing begins when multiple modules are ready and integrated, ensuring proper interaction between them.
• ✅ System testing and user acceptance testing follow, ensuring that the entire system works as expected and meets the customer's requirements.

Q & A

What is the V-Model in software development?

The V-Model is an extension of the traditional waterfall model where each development phase has a corresponding testing phase. It is named after the V-shape formed by the process stages, representing an improvement in feedback and testing involvement over the waterfall model.

How does the V-Model address the disadvantages of the waterfall model?

The V-Model addresses the major disadvantage of the waterfall model, which is the delayed feedback in testing. In the V-Model, testing is integrated into each development phase, ensuring that defects are identified and addressed early in the process.

What is the role of the testing team during the requirements phase in the V-Model?

During the requirements phase, the testing team starts writing the user acceptance test cases based on the gathered requirements. This early involvement allows them to spot potential gaps and issues before the development begins.

What is the system analysis and design phase in the V-Model?

In the system analysis and design phase, teams analyze how the new software will interact with other systems, including third-party and internal systems. Testers start writing system test cases during this phase to prepare for end-to-end system testing.

What is global design in the V-Model, and what happens during this phase?

Global design refers to the high-level design of the core application being developed. During this phase, the tech architects determine what changes are needed in the core system. The testing team writes integration test cases to test how the new application will interact with other systems.

What are unit tests in the V-Model, and who typically writes them?

Unit tests focus on testing individual modules of the software during the module-level design phase. These tests are usually written by the development team, but white-box testers may also write unit test cases if necessary.

What is the purpose of integration testing in the V-Model?

Integration testing in the V-Model occurs after individual modules have been developed and integrated. Its purpose is to test how the modules work together and ensure that the integration between different parts of the software functions correctly.

What is system testing in the V-Model?

System testing is conducted once the entire software is developed and integrated with other systems. It verifies that the complete system, including interactions with third-party or external systems, functions as expected.

What is user acceptance testing (UAT) in the V-Model?

User acceptance testing (UAT) occurs after system testing and is performed by business users or customers. It focuses on ensuring that the software meets the customer's requirements and is fit for use. The UAT team typically uses test cases written during the requirements phase.

Why is the V-Model considered advantageous compared to the waterfall model?

The V-Model is considered advantageous because it involves the testing team throughout the development process, allowing defects to be identified and addressed earlier. This reduces the risk of issues being discovered late in the development cycle, leading to a more efficient and higher-quality development process.

Outlines

00:00

🧑‍💻 Introduction to the V-Model in Software Testing

This paragraph introduces the V-Model, an improvement over the Waterfall Model in software development. The major drawback of the Waterfall Model was delayed feedback during testing, which the V-Model addresses by incorporating testing in each development phase. The speaker emphasizes the need to understand the Waterfall Model first, as the V-Model builds upon it. The V-Model's phased approach includes corresponding testing phases for each development stage, providing earlier defect detection and resolution.

05:00

🔍 Requirements Gathering and Early Test Involvement

This paragraph focuses on the requirements gathering phase, the first phase in both the Waterfall and V-Models. In the V-Model, the testing team gets involved early, writing user acceptance tests (UAT) based on gathered requirements. This early involvement helps identify gaps in the requirements before development begins. The main advantage of this phase is finding potential defects early, unlike in the Waterfall Model, where testing was delayed until much later.

10:01

🔗 System Analysis and Test Case Development

Here, the paragraph covers the system analysis and design phase of the V-Model. During system analysis, the focus is on how the software interacts with external systems. Testers write system test cases, focusing on the end-to-end functionality of integrated systems. This phase is crucial when multiple systems are involved in software development, such as third-party systems or internal subsystems that support a comprehensive application, like a banking application.

🌍 Global Design and Integration Testing

This paragraph discusses the global design phase, where the core application design is created. Architects plan the changes required in the core system, while the testing team writes integration test cases. The design includes both internal system integration and third-party interactions, ensuring the software is ready for comprehensive testing once modules are built. As the design happens, integration test cases are prepared for execution after code completion.

📦 Detailed Design and Unit Testing

This paragraph explains the detailed design or module-level design phase. Developers begin breaking the global design into smaller modules and start coding. Testers are responsible for writing unit tests, which are usually done by the development team but can be handled by white-box testers. Each module is tested individually through unit testing to ensure functionality before integration with other modules.

⚙️ Coding and Integration Testing Execution

This part covers the coding phase, where developers create the actual modules based on the design. Once modules are ready, the testing team begins unit testing, followed by integration testing. When two or more modules are integrated, integration tests are executed to verify the interaction between different parts of the system. This process ensures that integrated modules function properly as a whole before moving to the system testing phase.

🔄 System Testing and User Acceptance Testing

This paragraph explains system testing and user acceptance testing (UAT). After all modules are integrated and system-level testing is complete, the software is tested against third-party systems. Once system testing is passed, UAT takes place, usually conducted by business stakeholders or customers. UAT verifies if the system meets the user's needs. Since the UAT test cases were prepared early, this phase runs smoothly, allowing testers to ensure that the system aligns with business requirements.

📝 Conclusion and Benefits of the V-Model

The final paragraph summarizes the key advantage of the V-Model over the Waterfall Model: earlier and continuous testing involvement. In the V-Model, testing happens at every phase of the development cycle, allowing for the early detection and fixing of defects. This proactive approach improves overall software quality, making the V-Model more effective in reducing delays and costly errors. The speaker concludes by introducing the topic for the next tutorial, the iterative development model.

Keywords

💡V-Model

The V-Model is a software development life cycle model where processes are executed in a sequential manner, forming a V shape. Unlike the Waterfall model, the V-Model integrates corresponding testing phases at each stage of development. This approach helps to identify defects early by involving testers right from the requirement gathering phase. In the video, the presenter explains how the V-Model improves feedback loops compared to the Waterfall model.

💡Waterfall Model

The Waterfall Model is a traditional software development model where each phase flows sequentially from one to the next, without overlapping. Its main disadvantage, highlighted in the video, is the delayed testing phase, which means defects are often discovered late in the process. The V-Model was introduced to address these issues, making testing an ongoing part of each development phase.

💡Requirements Gathering Phase

This is the initial phase in both the V-Model and Waterfall model where the team collects and documents the requirements of the project. In the V-Model, testers are involved early in this phase to start writing user acceptance test cases based on these requirements. The early involvement of testers helps identify potential gaps in the requirements before development begins.

💡System Analysis

System analysis refers to understanding how the software will interact with other systems, especially in complex applications like banking systems. In the V-Model, this phase involves breaking down the system's requirements to analyze interactions with external and internal systems. Testers begin to write system test cases during this phase, targeting end-to-end system functionality.

💡User Acceptance Testing (UAT)

UAT is the final testing phase in the V-Model where actual users or business stakeholders test the system to ensure it meets their requirements. In the V-Model, the UAT test cases are written during the requirements gathering phase, allowing testers to prepare for this final validation early. The video emphasizes how this early preparation helps streamline the UAT phase.

💡System Testing

System Testing involves testing the entire integrated system to ensure all components work together as intended. This phase occurs after integration testing in the V-Model, where testers execute test cases that focus on the full system, including interactions with third-party and internal systems. The video describes how early preparation of system test cases ensures smoother testing at this stage.

💡Integration Testing

Integration Testing is the phase where individual modules are combined and tested as a group to identify issues with their interactions. In the V-Model, testers prepare integration test cases during the design phases, and these are executed once modules are integrated. The video illustrates this process with an example of a banking application, showing how different modules, like applying for a card and saving customer details, are tested together.

💡Unit Testing

Unit Testing is the testing of individual modules or components to ensure they work as intended. In the V-Model, this is usually done by developers, though white-box testers may also be involved. The video highlights how unit tests are written during the detailed design phase and executed once coding is completed for each module.

💡Detailed Design

Detailed Design refers to the phase where the overall system is broken down into smaller modules for development. In this phase, specific technical details are outlined for each component. Testers write unit test cases based on the module designs. In the V-Model, this phase ensures that the detailed design is closely aligned with test preparation, as explained in the video.

💡High-Level Design (Global Design)

High-Level Design, also referred to as Global Design, outlines the architecture and structure of the system, focusing on how the core application will function. It includes decisions about system interactions with external systems. In the V-Model, testers write integration test cases based on this design to verify how different modules will integrate later. The video uses the example of a banking system's core functionalities being designed at this stage.

Highlights

The V-Model is an improvement over the waterfall model, addressing the delay in feedback and testing phases.

In the V-Model, testing is integrated into every phase of software development, ensuring early defect detection.

During the requirements gathering phase, the testing team starts writing user acceptance tests to identify gaps early.

In the system analysis and design phase, testers create system test cases for end-to-end integration with third-party systems.

Global design focuses on how the core application will be developed, and testers write integration test cases during this phase.

The detailed or module design phase breaks down the high-level design into smaller modules, and unit test cases are written here.

Developers begin coding once the design is complete, and testers execute unit tests on individual modules.

Integration testing begins once multiple modules are ready and integrated, ensuring smooth interaction between components.

System testing is performed after all modules are integrated to verify how the entire system functions with external systems.

User acceptance testing (UAT) is conducted by business users to ensure that the final product meets customer requirements.

UAT uses test cases that were written during the requirements phase, allowing for efficient and targeted testing.

The primary benefit of the V-Model is that testing involvement in each phase allows for early feedback, improving quality.

Compared to the waterfall model, the V-Model reduces the risk of late-stage defects by involving testers from the beginning.

The V-Model is especially useful in complex systems that integrate with multiple third-party systems, ensuring seamless operation.

In conclusion, the V-Model's phased approach with concurrent testing ensures early defect detection, reducing overall project risks.

Transcripts

hello everyone welcome again in this

software testing tutorial

we are going to learn what is v model

so we have already understood about the

waterfall model in the previous tutorial

of a software development life cycle so

there is a waterfall model

that teams used to follow and because of

the disadvantages that we have discussed

in the waterfall model

the model got evolved so the major

disadvantage in waterfall model was

around the delay in the feedback right

or the testing

phase was delayed a lot in that

particular waterfall approach

so if you haven't watched the previous

tutorial please go ahead and watch it

first before you come to the v

model because both of them are

interrelated and

v model is a improvement over the

issues that were there in the waterfall

model so you need to understand

waterfall model first

before you are able to understand what v

model is

so as you can see on my screen the v

model as

the name suggests it's in the shape of v

rather than the waterfall approach

where in all the phases were one after

the other v model is bit of an

improvement

even though there is still the phased

approach and there are

you know phases after the other

one after the other but still there are

corresponding

phases of testing for each of the

development phase or the requirement

phase so let's understand

what exactly v model is and how software

development happens

when the team is following the v model

so the first phase of v model is the

requirements gathering phase which is

very similar to sdlc or you know

waterfall approach so requirements

is the first source of truth for any

software development team to start

working on any of the coding uh

or development activity so once

the requirements are available to

requirement gathering so in that

particular phase

in the software in the waterfall

approach there was no test involvement

at that particular phase so once the

requirements got

frozen only then the development

activity or the design

activity started in the waterfall

approach now because of that

the defects that could have been found

in the requirement phase

itself were delayed until testing or the

deployment happened

to overcome that v model was introduced

and in this

if you see there is a corresponding

involvement

of test team so as soon as the

requirements

are available testing team starts

writing the user acceptance

tests okay

so what the testing team does is they go

through the requirement

and based on those requirements they

start documenting

their test cases or basically at this

level they can

understand what the high level

requirements are and based on that

what customer is looking for and when

they understand those requirements

they go through those requirements they

are involved into the discussion

with the team with the customer then

they can

write the user acceptance test cases and

when they are

writing the test cases they come up with

any of the gaps

that might be there in the requirement

gathering phase

so that's the um you know first

involvement or the first within the

first phase itself the testing team

is involved in writing the user

acceptance test cases

now once the requirement are being

gathered and if you can see here after

the requirement phase then the system

analysis and design starts

so when we say system analysis in the v

model it's basically

say for example you are developing a

banking

application for for

distributing the cards for example right

so when you say uh the credit card or

debit card it's

it involves the complete life cycle and

there are different number of systems

that are involved so you will have a

system to

um you know to originate the card or

a person or customer will come to

originate or apply for the card right

once they apply for the card then that

card application goes into the backend

system where there will be business

process and the processing will happen

once the processing is happen then the

card goes for

embossing so the physical card right so

that goes to any third party or third

system

so those systems are usually not

maintained

by the banks right so bank uh

has the tie up with other system other

companies who do the card embossing or

create the physical cards

and send those similar is the case with

the uh

you know all those letter generation and

all so if that is the case there are

different

you know companies involved in systems

involved to

produce the physical card to produce the

letters etc

then that understanding comes into the

system

analysis so how that particular software

will interact with other underlying

system

that happens in the system analysis and

design and once that system analysis

is in progress testers can at the same

time

write their system test cases

all right so what system test cases will

do is

they will test or those test cases will

target

the end-to-end system right so they'll

target

when all the systems different systems

third-party systems are integrated

and how the overall testing will be

performed

in the end-to-end integrated system be

do you know like third-party system or

internal other systems that are

you know available or involved in that

particular software

development right the next phase is

basically the global design

when you say global design so now you

have understood about the system test

cases

system test cases will have integration

with other systems as well

right but most of the time when you talk

about the actual core development it's

basically

you are developing an application and

then that application might

integrate with other systems okay so

that's what we do in system analysis and

design but the global design is

how you will design that core

application

okay so if i say launching a new card

so what all is required in the core

system of the bank

to launch a new card a new credit card

so that goes into the global design

wherein

the tech architects will understand what

all is required in the core system to be

changed and implemented

right so that is what happens in the

high level design

and in the system design and analysis

system analysis and design

along with that you know that software

or the core design

they think about how that system the new

application they are building will

integrate with third-party systems or

other systems that's what happened in

system analysis

phase so in the global design phase once

the global design is ready how the

system will be

implemented or the software will be

implemented in that particular

you know that application uh

then in that phase itself what

testing team do is they write their

integration test cases right so they

write integration

tests all right so now with this

phase the test theme is also involved to

write

whenever the design is happening they

write the integration test cases

and once the actual code is ready

they'll execute

those test cases similarly when it comes

to the detailed design or the module

level design so when we

have the high level design and then the

developers will need to

develop small modules to make it you

know like the overall software

so they won't develop everything all at

once so once the

software design is there they'll break

it down into smaller modules and then

team will start developing those modules

or developers will start

developing those modules that is what

happens in the detail design or module

level design

so model level design during the module

level design the

testers will go through the module level

design and

they will write their unit tests right

so you need tests so usually most of the

time you will see unit tests

are written by the development team but

there might be possibility that if you

are a white box tester

you might be required to write the unit

test cases if you are a tester

or white box tester in the team right

so this is what happens in the detailed

design or the module

design so unit test cases are being

written

for the unit test phase now once all

these design

phases are complete then comes the

coding phase so

once the design is ready or the low

level design is ready

then the developers will start coding

for those smaller modules and once those

modules

are ready then the test team because

they have already written the test cases

through

going through the documentation they

will start testing

or doing the unit test right so once the

code is ready

the execution will start so the actual

execution will

happen the application will be launched

so in the unit test case there will be

tools used

to do the unit test and if

it is one done by developers then

they'll do it otherwise if you're a

white box tester you will actually

execute the code whatever

developers have coded for those modules

and you will run the unit testing

once couple of modules are ready and

they are integrated okay so couple of

modules in the application are ready

and they are integrated say for example

um in the cards uh so we are trying to

launch a new card right so

so there'll be couple of modules so

apply

card right so apply card

and even in the apply card there could

be you know apply card

uh with minimal details so say for

example minimal

customer details

all right so say for example this is

considered as one module so what

you know you will do is in the unit test

this particular module

you will have a test case which will

have the minimal details into that

particular module

and as part of the unit test they will

test this

module only okay similarly when there

are couple of modules

ready so apply card is ready and then

this apply card module once the card is

applied then the card details need to

save into the database

right so this could be another module

where there are there is some work that

has been done

and little bit integration between the

front-end and back-end db

has been done so if these two modules

are integrated that's

what happens in the integration testing

so there are a couple of modules that

have been

worked upon if they are integrated then

integration testing

starts okay so this is what the testing

team will do

in if couple of modules are integrated

they will start integration testing

once all the modules are completed

integration testing has been completed

then they'll target at the system level

so the whole

software has been developed now how that

software

or application is integrated with other

third-party systems or

other systems that what happens in the

system testing

so the testing because they have already

written system test cases they'll

start executing system testing or

executing those test cases

once system testing is passed then

user acceptance testing which is mostly

done by

people from the business or you know

customers involvement

which targets about whatever has been

built

in the system whether that is fit for

use or that meets the customer

requirement so that's

what is done into the user acceptance

testing

and because user acceptance test cases

have been written during the

requirements phase

then user acceptance testing can

use the same test cases to execute the

test in the user acceptance testing

phase right so this is a brief

introduction of the model

and how we model will be advantages

as compared to the waterfall approach

that we have seen so waterfall approach

the disadvantage was the testing

involvement was very late

and in order to overcome that the v

model was introduced and testing team

was

introduced in every phase of the

development life cycle

and because of that lot of defects were

identified early in the life cycle so

because testing team is involved in

every phase

so they can provide the feedback or

inputs for

the defects in each and every phase

rather than just waiting for the testing

at

one particular stage of software

development life cycle

all right so um that's all about

the v model in his dlc or um software

development life cycle

hope this was helpful um in the next

tutorial i'll talk about

the iterative development model so

that's all for this tutorial

please do share and subscribe and thank

you very much for watching