ISTQB FOUNDATION 4.0 | Tutorial 11 | TDD, BDD, ATDD | DevOps and Testing | CTFL | TM SQUARE

Summary

This tutorial covers ISTQB Foundation level certification, focusing on testing within the SDLC, particularly agile methodologies and the integration of testing in DevOps. It introduces Test-Driven Development (TDD), Behavior-Driven Development (BDD), and Acceptance Test-Driven Development (ATDD) as approaches where tests are written before code, promoting early testing and iterative development. The video also explores DevOps, emphasizing the synergy between development, testing, and operations to achieve common goals, and discusses the benefits and challenges of implementing a DevOps culture, including continuous integration and delivery (CI/CD).

Takeaways

• 📘 Testing in the SDLC: The tutorial covers testing throughout the software development life cycle (SDLC), focusing on Chapter 2, Section 2.1.
• 🆕 New Syllabus Additions: The script introduces testing as a driver for software development and the integration of DevOps and testing, which are new to the ISTQB syllabus.
• 🔄 Agile Methodology: Discusses test approaches in the agile methodology, including Test-Driven Development (TDD), Behavior-Driven Development (BDD), and Acceptance Test-Driven Development (ATDD).
• 🛠️ Shift Left Approach: Highlights the 'shift left' philosophy, where testing is conducted earlier in the development process to drive development and catch issues sooner.
• 📝 Test-First Principle: Emphasizes writing test cases or scripts before the actual code to ensure the code meets the requirements when developed.
• 🔬 TDD Details: Explains Test-Driven Development as a process where unit tests are written first, followed by code that satisfies the tests, and then refactoring.
• 🎯 ATDD Focus: Describes Acceptance Test-Driven Development, where tests are derived from acceptance criteria, useful for User Acceptance Testing (UAT).
• 🌐 BDD for Stakeholders: Behavior-Driven Development uses natural language test cases understandable by all stakeholders, which are then translated into executable tests.
• 🤝 DevOps Integration: Introduces DevOps as an approach that combines development and operations, including testing, to achieve common goals.
• 🔄 CI/CD Pipeline: Discusses the importance of Continuous Integration (CI) and Continuous Delivery (CD) in DevOps for faster feedback and higher quality code.
• 🚀 Benefits of DevOps: Outlines the benefits of DevOps, such as fast feedback, reduced regression risk, and the promotion of automated processes.
• 🛑 DevOps Challenges: Notes the challenges of implementing DevOps, including the need for a defined pipeline, expertise, and additional resources for test automation.

Q & A

What is the main focus of Chapter 2 in the ISTQB Foundation Level certification tutorial?

The main focus of Chapter 2 is discussing testing throughout the software development life cycle (SDLC), with a specific emphasis on testing approaches in the context of agile methodologies and the integration of testing in DevOps practices.

What does 'TDD' stand for in the context of agile testing methodologies?

TDD stands for Test Driven Development, an approach where unit test cases are written before the unit code, and the code is then written to satisfy the tests.

How does the principle of 'Shift Left' relate to testing in the agile methodology?

The 'Shift Left' principle involves moving testing activities to the earlier stages of the development life cycle, emphasizing early testing and integration of test cases with development to drive the coding process.

What is Acceptance Test Driven Development (ATDD) and how does it differ from TDD?

ATDD focuses on deriving test cases from acceptance criteria, which are the satisfactory conditions of a user story. Unlike TDD, which is technically focused, ATDD is business-facing and is particularly useful for User Acceptance Testing (UAT).

What is Behavior Driven Development (BDD) and how does it facilitate communication among stakeholders?

BDD is an approach that uses test cases written in simple natural language, which is easy for all stakeholders to understand. It typically follows the 'Given-When-Then' format, allowing for clear communication of the expected behavior of the system.

What is DevOps and how does it integrate development and operations?

DevOps is an organizational approach that aims to create synergy by getting development (including testing) and operations to work together closely to achieve common goals, emphasizing continuous integration and delivery (CI/CD) and eliminating the traditional separate testing phase.

What are some of the key benefits of implementing DevOps in an organization?

Benefits of DevOps include fast feedback on code quality, reduced risk of regressions due to automated testing, promotion of high-quality code submission by developers, and the ability to build, test, and release high-quality code faster through automated delivery pipelines.

What challenges might an organization face when adopting DevOps practices?

Challenges include the need to define and establish a DevOps delivery pipeline, the dependency on having knowledgeable personnel, the need to introduce and maintain CI/CD tools, and the requirement for additional resources to set up and maintain test automation.

How does DevOps facilitate the shift of certain non-functional code quality characteristics to an earlier phase in the development process?

DevOps promotes the integration of non-functional testing such as performance and security into the early stages of development, like unit testing, to identify potential issues early on and reduce the limitations of performance issues.

What is the significance of the 'Gherkin' language in Behavior Driven Development?

Gherkin is a simple, domain-specific language used in BDD to describe software's behavior in a way that is easy for all stakeholders to understand. It allows for the translation of human-readable descriptions into executable test scripts.

How does the tutorial suggest that a tester can enhance the efficiency of the development process in agile methodologies?

The tutorial suggests that by writing test cases first and giving them to developers, the development process can be more efficient. Developers can write code to make these tests pass, reducing the time spent on defect reporting and tracking, and allowing for faster identification and resolution of issues.

Outlines

00:00

📚 Introduction to Testing in SDLC and Agile Methodologies

This paragraph introduces the tutorial on ISTQB Foundation level certification, focusing on Chapter 2 about testing in the context of the software development life cycle (SDLC). It highlights the inclusion of newly added topics such as testing as a driver for software development and the intersection of DevOps and testing. The speaker discusses the agile methodology's test approaches, specifically Test-Driven Development (TDD), Behavior-Driven Development (BDD), and Acceptance Test-Driven Development (ATDD), emphasizing their role in directing the development process through early testing and a 'shift left' strategy.

05:02

🔍 Deep Dive into Agile Testing Approaches

The second paragraph delves deeper into the three agile testing approaches: TDD, ATDD, and BDD. It explains that TDD involves writing unit tests before the code, validating the code against these tests, and then refactoring both tests and code. ATDD is distinguished by deriving tests from acceptance criteria, making it useful for User Acceptance Testing (UAT) and aligning with business-facing requirements. BDD is characterized by its use of natural language to express system behavior in test cases, which are then translated into executable tests. The paragraph underscores the importance of these approaches in the agile methodology and their practical application in software development.

10:02

🛠️ The Integration of DevOps and Testing

This section introduces the concept of DevOps and its significance in modern software development. It describes DevOps as an organizational approach that aims to create synergy between development, including testing, and operations to achieve common goals. The paragraph explains how DevOps seeks to embed testing within the development process, allowing for parallel testing and direct transition to operational environments. It also touches on the cultural shift required within organizations to adopt DevOps practices, such as continuous integration and continuous delivery (CI/CD), and the benefits of automated testing in ensuring code quality and reducing regression risks.

15:05

🚀 Benefits and Challenges of Implementing DevOps

The final paragraph discusses the benefits of adopting DevOps, such as fast feedback on code quality, minimized regression risks due to frequent automated testing, and the promotion of high-quality code submission by developers. It also addresses the challenges associated with DevOps, including the need for a well-defined and established delivery pipeline, the introduction and maintenance of CI/CD tools, and the additional resources required for test automation. The speaker wraps up the tutorial by summarizing the key concepts covered and encouraging viewers to continue learning and exploring the subject matter.

Keywords

💡ISTQB Foundation Level Certification

The ISTQB Foundation Level Certification is an entry-level qualification for software testers, demonstrating foundational knowledge in software testing principles and practices. In the video, this certification serves as the context for discussing various testing methodologies and approaches within the software development life cycle (SDLC).

💡SDLC

SDLC stands for Software Development Life Cycle, which is a process that describes the stages involved in the development of a software product. The video script discusses testing within the context of the SDLC, emphasizing the importance of testing at various stages to ensure software quality.

💡Agile Methodology

Agile Methodology is a flexible approach to software development that promotes iterative progress, collaboration, and customer feedback. The script introduces testing approaches such as TDD, BDD, and ATDD, which are integral to the Agile Methodology, focusing on writing tests before code to drive development.

💡TDD (Test-Driven Development)

TDD is a software development technique where tests are written before the code that implements the functionality. It is highlighted in the script as a way to ensure that code meets the requirements and is a fundamental practice in Agile development, fostering a tight loop of writing code to pass tests.

💡BDD (Behavior-Driven Development)

BDD is an Agile approach that encourages the use of natural language to describe software behavior, making it accessible to all stakeholders. The script explains that BDD uses 'Given-When-Then' scenarios to define test cases, which are then translated into executable tests guiding the development process.

💡ATDD (Acceptance Test-Driven Development)

ATDD is a practice where tests are derived from acceptance criteria, ensuring that the developed software meets the user's requirements. The script mentions that ATDD is particularly useful for User Acceptance Testing (UAT), as it helps confirm that the software fulfills the necessary conditions for acceptance.

💡DevOps

DevOps is an organizational culture and practice that aims to reduce the gaps between software development and operations by promoting collaboration and integration. The script discusses how DevOps integrates testing within the development process, emphasizing the importance of continuous integration and delivery (CI/CD).

💡Shift Left Approach

The 'Shift Left' approach refers to moving testing earlier in the SDLC to find and fix defects sooner. The script explains that this approach is central to Agile testing methodologies, allowing for iterative development and continuous feedback, which is crucial for maintaining software quality.

💡CI/CD (Continuous Integration/Continuous Delivery)

CI/CD is a set of practices in DevOps that involves automating the integration and delivery of code changes. The script describes CI/CD as a way to establish stable test environments and reduce the need for repetitive manual testing, which is a key benefit of the DevOps approach.

💡Regression Testing

Regression Testing is the process of verifying that changes to the code have not adversely affected existing features. The script notes that the risk of regressions is minimized in DevOps due to the frequent execution of automated regression tests, ensuring that new code does not break existing functionality.

💡Test Automation

Test Automation involves creating scripts or programs to execute tests automatically. The script discusses the importance of test automation in DevOps, as it requires additional resources and can be challenging to establish and maintain, but ultimately leads to faster feedback and reduced manual testing efforts.

Highlights

Introduction to ISTQB Foundation level certification and Chapter 2 focus on testing throughout the SDLC.

Discussion on 2.1.3 - Testing as a driver for software development.

Introduction to newly added syllabus topics: TDD, BDD, and ATDD in agile methodology.

Explanation of Test-Driven Development (TDD) and its principle of writing test cases before code.

Detailed process of TDD where code is validated by pre-written test cases, reducing defect reporting time.

Acceptance Test-Driven Development (ATDD) focuses on deriving test cases from acceptance criteria.

Behavior-Driven Development (BDD) uses natural language for test cases to express desired application behavior.

Introduction to the 'Given-When-Then' format used in BDD to write test cases.

Overview of DevOps and its integration of development, including testing, and operations.

DevOps emphasizes continuous integration (CI) and continuous delivery (CD) for faster code release.

Automated tests in DevOps trigger on every code check-in, enabling quick feedback and regression testing.

CI promotes a shift-left approach by encouraging developers to submit high-quality code with automated tests.

Advantages of DevOps include fast feedback on code quality and minimized risk of regressions.

Challenges in DevOps include the need for expertise in establishing CI/CD pipelines and maintaining automation.

Summary of key concepts discussed, emphasizing the benefits and challenges of adopting DevOps in organizations.

Transcripts

Hello friends and greetings for the day

welcome back to another tutorial on

istqb Foundation level certification we

are in Chapter 2 talking about testing

throughout the sdlc and continuing ahead

with 2.1 which is testing in context of

software development life cycle as this

is a big topic we have the second

segment which we are covering today that

is

2.1.3 testing as a driver for software

development and

2.1.4 that is devops and testing indeed

these two topics are those two topics

which are newly added to our syllabus so

let's look at them in more

detail well the first thing coming into

our discussion today is of course

talking about some of the test

approaches from the agile methodology as

this is a new addition to the syllabus

certainly we are discussing this as a

part of foundation level for the first

time however this topic is already

included in the next level which is

agile certification of istqb so if in

case you are moving to the next level

you will learn this topic once again so

at this point of time we are just

talking on a very high level as an

introductory topic that what are tdd bdd

and atdd in terms of applying testing

approaches to that of the agile

methodology in a very short and simple

way we are talking about that these

three techniques are basic basically a

similar development approaches or B

basically testing approaches the reason

we have a Twist in this terminology

whether it is a development approach or

it is a testing approach is because the

development is driven by the testing

that means the test cases are written

first or automation test scripts

actually are written first and then the

development will be done so it's right

opposite to that of what happens in our

general life cycles and in these

approaches it is right opposite to that

so let's exactly look what the content

is trying to convey us here so so of

course these are very similar to each

other but here the similarity is that

the tests are defined as means of

directing the development process altoe

each of these approaches implements the

principle of early testing and follow a

shift left approach however shift left

approach is coming in our next

discussion but shift left approach is

more of like shifting something in the

left hand side on the life cycle so as

we all know testing happens later in the

life cycle which is on the right hand

side is moving before something which is

used to happen before that so

development is a before um an activity

which happens prior to test executions

but now the test cases are written

before development can even kick off so

how exactly this basically cats the need

of the agile methodology and in this

case of course the test cases are

written or tests are defined before the

code is written the support they support

an iterative development model that

means more of like aile methodologies

only and these approaches are generally

characterized as follows the very first

one here is tdd on a very high level

test driven development approach is

going to help you with directs the

coding through the test cases instead of

extensive software design and then test

are written first then the code is

written to satisfy the test and then the

test are test and code are refactored so

these are very very high level

information what they're trying to give

you but does not make any kind of

detailed explanation so let me just add

few more lines on top of this which is

beyond the syllabus that test driven

development is an approach where the

unit test cases are written prior to the

unit codes that means simple programs

when they are written we make use of

test cases being written first so how

does this principle even work in reality

so if you deep dive into the process you

understand that a code will be validated

by set of test cases as far as the test

passes the code is appropriate create or

meeting the requirements if in case the

code has anomaly the test cases will

fail or test cases will identify the

defect and the developer has to fix it

in order to meet the requirements but

when we realized that the tests are

something which finally validate the

code not anything else like design and

other things then why don't we write

those test cases prior to development

and give those test to the developer

that hey now you go in a repeated tight

Loop of cycles of writing code in order

to make this test pass that makes sense

right so a tester will write test cases

and give it to developer and then the

developer will start writing code in

order to make that test pass as in when

they run the test if the test fails that

means code has something wrong and I'm

reducing a lot of time in reporting a

defect reporting or following up or

tracking the defect foreclosure talking

about all those collaborations making

other people understand now the

developer himself or herself understands

that where my code is wrong why my test

is is not passing right and that reduces

a lot of human effort in fact very

proficient and faster when compared to

our understanding of the life cycle so

in that context we tried this out and

here the tests were written before the

development happens and these test are

basically technically written that's the

reason this is only applicable at the

unit level yes you can say that a

developer one will be writing the test

cases here for units and developer two

will be writing the code and once the

test passes we groom the code we write

more additional steps and make this code

applicable to the rest of the body

similarly the next one we have is called

as atdd which stands for acceptance test

driven development and here we do have

uh options like derived test from

acceptance criteria that's something

unique as a part of the system design

process and then tests are written

before the part of the application is

developed to satisfy the test the only

difference here is the tests are not

technically written that means they are

not driven by the technical programs or

the expectation rather the test cases

are derived from the acceptance criteria

so in aile it is very important that for

a user story to be called as done or

completed it should meet the defined

acceptance criteria so as acceptance

criteria is something which are

satisfactory criterias of a user story

then deriving test cases from them would

make a lot of sense indeed these tests

are also useful for uat that is more

driven from a customer perspective Ive

or business facing thus these test cases

which are written are very helpful in

uat as well that is user acceptance

testing so the only hairline difference

between this approach is the test cases

derived from our acceptance criteria and

in the same line if I go with the third

one that is behavior driven development

this expresses the desired behavior of

an application with test cases written

in a simple form of natural language

which is easy to understand by any

stakeholder usually using the format

that is given when then and test cases

are then automatically translated into

executable test so again if you talk

about the behavior driven development

again the difference here is that the

test cases are derived from the

requirement the behavior of the system

so one is technical facing second is

business facing and third is requirement

facing that is user perspective so here

we do have a very a very common language

called as Garin and that kin language

stands for given when then where things

are written in three steps given certain

expectations or prerequisites when a

user performs these steps then this is

what you should expect to happen so if

you just write this language we can

translate this into a programmable

executable test scripts and that will be

further executed and then the

development will happen on top of it so

put together these are some very very

specific and Niche approaches used in

agile methodology but as today most of

the organizations are very much driven

by aile methodology it certainly adds a

lot of value for anyone to understand at

Foundation level that what are these

introductory test approaches the next

important topic we're talking about is

devops and testing again this is one of

the new topics being added to the

syllabus for the first time and here we

just trying to compare and understand

that how devops and testing are going to

work in today's scenario and here we are

also introducing you to understanding of

the devops keyword that many people at

this point of time should know that what

is devops altogether so devops is

basically an organizational approach

aiming to create Synergy by getting

development which is including testing

and operations to work together to

achieve a set of common goals now if I

talk about the devops as a word It's a

combination of development and

operations so development of course is

the coding and implementation phase and

operation is when it goes life or get

into the environment that is targeted

environment and it can run there so that

is more of like uh production or maybe

you know we talk about the uat where

finally it goes into the target

environment and we check whether it is

working and operational or not so we are

talking about eliminating the stage of

testing but does that mean we are not

talking about testing at all no devops

is trying to say that hey devops means

Dev part will include an embedded

testing as a part of it and uh along

with development parallel testing will

take place and then it will directly go

to the operational environments rather

than having a dedicated phas for testing

in between Dev and operations so they

are skipping that particular phase

combining it together with Dev and then

trying to move directly to operations

and that's another one of the trending

thing so let's see what exactly the Deep

dive of devops is and how this could be

applied to the organization so devops

when it comes to uh the understanding of

the real time of course the when the

team works together they will be able to

do

every time a new code is checked in

every time a new piece of code has been

merged with the existing part of the

application or existing codes it would

certainly allow us to trigger an

automated test which would help us to

check the build verification and the

regression as well so automation test

scripts can be written pretty well and

that could even go in line with our

automated

confirmations of all the tests what you

really need to do devops requires a

culture shift within an organization to

bridge the gaps between development

which again includes testing and

operational operations while treating

their function with equal value right

also devops promotes test autonomy fast

feedback integrated tool chains and

Technical practices like continuous

integration and continuous delivery I

think this is what I was trying to

elaborate just a moment ago that when it

comes to devops it's more about every

time a developer is trying to write a

code and check into the repository every

single check-in should trigger a build

verification test and many other

activities like static analysis unit

test cases or regression test Suite to

be triggered automatically step by step

to make sure that the new unit is

working fine at the same time when

integrated with existing piece of a code

it should not break that that means even

the regressions are not introduced so in

that context continuous integration can

be achieved and continuous delivery can

be done so we also have the terminology

as cicd very commonly known and called

as continuous integration continuous

deployment so we have dedicated tool

support for these kind of activities but

again we should spend some time to Deep

dive into each of these that how exactly

it can be achieved in reality another

important thing here is this enables the

team to build the test and release high

quality code faster through devop

delivery pipelines indeed why not if I

follow the discussion what we just had

for the last few minutes we understand

that if such things can be automated or

could be integrated as a part of a

pipeline where the new code is checked

in and all the other tests are triggered

then a lot of effort and time being

consumed traditionally can be reduced

finally at the end we would like to talk

also about some of the quick benefits

and limitations of having devops in an

organization I think keeping it very

straightforward at this point of time we

don't want to Deep dive and correlate to

that of the real-time Industries or how

these practices actually become

advantages or drawbacks of having devops

but on a high level we'll give you a

quick outline that what does this even

mean so talking about the first

advantages of devops so from the testing

perspective some of the benefits of

devops are that is fast feedback on the

code quality and whether changes

adversely affect existing code I think

that's very straightforward what we have

been talking so far that you will get a

quick response because as in when the

code is checked in you'll have a quick

response right there right you don't

have to wait for deployments then run

your test cases a deleter phase and so

on you'll get a quick response and

second important thing is that is the

adverse side effect which is regressions

also to talk about CI promotes a shift

LIF approach in testing by encouraging

developers to submit high quality code

accompanied by component tests and

static analysis so I told you some of

the activities which we look forward to

automate as a part of our CI pipeline

includes the static analysis code sorry

static analysis investigation and uh we

do talk about unit test cases we do talk

about the regression test suite and many

other things which are actually a part

of this pipeline additionally it

promotes automated process like cicd

that facilitates establishing stable

test environments also increases the

view on non-functional code quality

characteristics which are certainly

going to be evaluated then and there

itself as we do understand we try to

prioritize our performance and security

and many other non-functional test to

early stages like unit testing the

reason is if I could identify the

anomalies in the code which is written

for a simple piece of program then I

would be able to detect the memory leaks

then and there and reduce my limitations

of performance issues so in that context

we also can very well uh have one of the

advantages that some of the quality

characteristics like performance and

security can be even pre ped or shifted

left to an early phase additionally uh

if I talk about automation through a

delivery pipeline reduces the need for

repeative manual testing of course the

more we talk about automation the less

the manual repeative effort will be and

the more we look at automations the

faster the process will be so in that

context we look forward to have more and

more automations in place when it comes

to devops or especially processes like

agile all we have another Point here to

talk about is the risk in regression is

also minimized due to the scale and

range of automated regression test so

the more frequently the Direction test

cases takes place the less the risk of

failure will be that means the later the

often we do or the less we do regression

testing the chances of regressions being

missed are very high but given that in

devops we are very tightly working

between the code and the test executions

we certainly have a very good reduction

in the risk of regressions so we'll

identify them as soon as possible but

nothing comes without a cost so of

course there are certain challenges what

we have to deal with when it comes to

devops and some of them are listed here

that is devops is not without its risk

and challenges and that includes the

devops delivery pipeline must be defined

and established someone in your

organization for the first time should

introduce this people should be well

knowledgeable on that if the team is not

aware of what is devops and how do we

make use of it how do we automate things

how do we trigger it and connect

different tools to one item that is C

pipeline we will not be able to achieve

that so someone has to introduce it

someone has to establish it with the

right set of knowledge so we need a

devops guy for sure so there will be

some dependency and maybe the expertise

also matters there it's just not that

someone with the basic knowledge of

devops can really achieve that on the

other hand we do have cicd tools must be

introduced and maintained that means a

new headache will be a part of your

journey the tools and how exactly you

will be maintaining that over a period

of time and the last but not the least

we have the test automation requires

additional resources and may be

difficult to establish and maintain them

so you would need more resources like

the test data the art artifacts the

environment and lot many other things

which contributes to the setup of the

automation for this devops process so

put together there were some interesting

Concepts to discuss today and we had

learned them pretty well from the

syllabus point of view and a little

Beyond as promised always so that's all

from this particular tutorial team

should you have anything else feel free

to comment below I'm always there to

address your queries and answer them

well till then keep learning keep

exploring keep understanding the context

thanks for watching the video team and

happy

[Music]

learning

[Music]