Categories: Uncategorized

by Jerome Josephraj

Share

BDD is not testing

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:

Traditional SDLC and Testing

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.

For privacy reasons YouTube needs your permission to be loaded. For more details, please see our Footer.
I Accept
Executing BDD Scenarios

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:

Traditional Test case document

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:

For privacy reasons YouTube needs your permission to be loaded. For more details, please see our Footer.
I Accept
Automate BDD in Minutes using NoCodeBDD

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.

STAY IN THE LOOP

Subscribe to our free newsletter.

Related Posts

View all

  • Continue reading
  • With NoCodeBDD, teams can automate Behavior-Driven Development (BDD) Scenarios for mobile applications with few clicks. To create test automation for mobile scenarios, typically, one would use Appium. Using NoCodeBDD, all you have to do is: Following gif shows how this is done for a sample mobile application: NoCodeBDD Mobile Automation NoCodeBDD […]

    Continue reading
  • if("student".equals(userType)){ Assert.assertEquals("STUDENT REGISTERED SUCCESSFULLY",actualMsg); }else{ Assert.assertEquals("ALUMNI REGISTERED SUCCESSFULLY",actualMsg); } When you have test code written like that given above—or. in other words, the code is written to assert an outcome based on conditional logic—it won’t test the scenario as it should. When writing test automation code for behavior-driven development (BDD) […]

    Continue reading
  • There is a general mis-conception that BDD should be used for testing. Many projects consider using BDD during “Testing phase” and only the QA team uses BDD. When BDD is rolled out this way, the teams don’t see the benefits. In this short video, I have explained how Behavior Driven […]

    Continue reading