Contrary to popular belief, behavior-driven development (BDD) is not actually used for testing. Instead, BDD is a collaborative process that allows development teams to understand the requirements better, keeps them all on the same page, and facilitates better testing. And it’s not a testing tool or a testing framework — it’s better. It helps the entire team to deliver high-quality software.
In this article, let’s look at how BDD is different from traditional testing and how it can massively help development teams deliver high-quality software faster. However, before we look at the differences, let’s look at what traditional testing is.
Traditional Functional Testing
There are two broad, generally recognized types of testing: Whitebox Testing and Blackbox testing. With Whitebox testing, you actually need to know the internal working of the application and the code base. Typically you would use Unit tests to do Whitebox testing. Unit tests purport to test the smallest units of code — typically, individual lines or modules in a program. I have already covered the difference between TDD and BDD in my blog.
Blackbox testing is anything that looks at the functionality of the systems without any context to the code. An example of Blackbox testing is functional testing done at the UI level. In order to do this, the user doesn’t need to know the internal code structure. Many users confuse BDD with functional testing. Let’s look at what functional testing is and in this blog, I will be covering the difference between functional testing and BDD.
Functional and system tests check whether a particular feature works correctly, that the system as whole works, and that no other issues have regressed due to this change.
Typically, the life cycle of this process is as follows. The developers take the user story, implement a solution, and pass the developed code to the tester. The testers then go through the manual or the automated script, checking whether the solution works as expected. Any issues they identify during this testing phase are reported to the developer, who fixes them, and the corrected code gets retested again. Once the testers are satisfied that the testing works as expected, the final solution is shown to the product owner for approval. This is shown in the image below:
As part of functional testing, quality assurance (QA) personnel write test cases in a spreadsheet or a test management tool. QA writes these test cases to find bugs in the solution based on the QA’s interpretation of the requirement. QA is responsible for identifying the bugs; developers are responsible for fixing the issues; the product owner is there to communicate a requirement in such a way that both developers and testers understand, and the scrum master or project manager is there to pull the entire team together and making sure the team delivers high-quality software on time.
What is Behavior-Driven Development?
BDD is about collaborating between different stakeholders, mainly the three amigos, to discuss and derive real-world scenarios. Teams define these scenarios using a language called Gherkin, which follows the natural language syntax but follows a certain format to give structure and meaning. These scenarios then form a contract between different team members, and when testers automate these derived scenarios, they execute them to make sure the implemented solution works as expected, as shown in the following video.
How is BDD Different from Traditional Functional Testing?
Let’s start with the cliche “prevention is better than cure.” When you practice BDD, this is exactly what you do.
If you are already collaborating as part of your Agile processes, you may be wondering how BDD is different. The biggest difference is that when the team collaborates and discusses all possible scenarios, the details can be lost as the team works through them. There is no process to check whether the teams are adhering to the scenarios that were discussed and agreed upon.
image referenced from: https://www.pinterest.co.uk/pin/417638565429425004/
As part of Agile, teams must already be collaborating and even be deriving these scenarios —maybe not be in a Gherkin format, but maybe in a format, everyone in the team understands. The issue with this process is that there is no process that could actually ensure that the derived scenarios are getting executed as expected. Let’s look at an example below.
The following sample scenario comes from one such Agile collaboration:
Scenario: Users should be able to register successfully when they fill in all mandatory fields on the registration page.
QA would use that scenario and create a test case document that looks something like the following:
A significant issue stands out: who checks and how do they check that the translation from the scenario to the test case document is correct? What happens if the QA misunderstood the scenario and came up with an incorrect test case? The BA or the product owner is not interested in this kind of detailed document — which is imperative — and may not actually test the behavior. In the next section, we will show how BDD addresses this.
How does BDD address this gap?
So, here’s a summary of the issues with the process of traditional testing:
1. You lose details between the time the scenarios are discussed during the start of the development process or sprint.
2. When QA takes the scenario and either write a manual test case or automates it, the scenario might turn into an invalid test case as a result of the QA’s understanding.
3. There is no direct correlation between the scenario and the test the QA is running.
4. Since either manual or automated testing of the scenario is expected to be done by the QA, the quality becomes QA’s responsibility.
If you want to address all of the above, the logical steps you should take is:
1. Derive the scenarios in detail and document them. Get all team members to always refer to this document when in doubt.
2. Get the QA to use the scenario to test the application — not through another document for each of the scenarios
3. Get the devs to use those scenarios to test their implemented scenario. In other words, the devs can confirm that their implementation is successful only when all the agreed scenarios pass.
If you can achieve the above three logical steps, then you are pivoting the entire team to work from this one single source of truth. BDD is nothing but deriving this single source of truth and getting the entire team to work from this document.
One of the first things that happen in a BDD process is collaborating and deriving real-world scenarios. These scenarios are agreed upon and documented as shown below. Then, the developer implements these scenarios, the QA writes automation scripts for these scenarios, and the product owner knows exactly what the team is working on.
There is no extra layer or a document or a test case spreadsheet/application to test the scenario that is in a format that the product owner doesn’t understand. And this is where BDD makes a big difference. In other words, you write your specifications and execute them directly without the need for an extra level of a translated document, which may or may not exactly map to what is documented during the collaboration process.
One of the biggest benefits of BDD is automation. However, using script-based tools like Cucumber is expensive, takes time, and requires resources with specific coding skills. NoCodeBDD was created to address this issue. In the next section, let’s look at how NoCodeBDD helps you accelerate BDD automation.
How can you accelerate BDD Automation?
Using NoCodeBDD, you can accelerate your BDD Automation by 10X. NoCodeBDD is built to address complex automation issues. Using NoCodeBDD’s built-in modules, anyone — even people without coding skills — can automate the scenarios, as shown in the video below:
At the time of writing this blog, NoCodeBDD supports UI, Mobile, API, Relational Database, and IBM MQ automation. You can also write a custom script to address any edge case the product doesn’t support. You can download a free version of NoCodeBDD at the following link: https://www.nocodebdd.com/download.
Jerome Josephraj is the Founder and CTO of NoCodeBDD. He has more than 20 years of experience in Software Development and have been rolling out Behavior Driven Development for large projects in United Kingdom. He has a strong Java Development Background and have been working as a Technical Consultant. In one of his recent large enterprise projects, he has successfully rolled out Behavior Driven Development consisting of more than 1000 scenarios. He was also the Founder of http://www.campusinteraction.com, a student analytics portal, which was later bought by Preludesys. Based on his previous start-up experience and a strong Behavior Driven Development experience, he founded NoCodeBDD to accelerate BDD automation by 10x.