5 Examples of Test-driven Development Frameworks You Must Know

No one can deny the value of code testing. But knowing how to do it, and which testing frameworks to use, is another story.

Sharing is caring!

by Matias Emiliano Alvarez Duran


To test or not to test, that is the question. 

Well, not quite: if Shakespeare wrote the Agile manifesto, he’d have said, “to test, yes. But when and how? That is the question.”

Because no one can deny the value of code testing. But knowing how to do it, and which testing approach to use, is another story. To help you up your testing game, we’re putting the spotlight on test-driven development (TDD).

In this article, we’ll talk about TDD frameworks, show you how and why TDD should be used, and supply you with great examples of when to try it out.

Table of contents

Ready to build your own custom software with a team that cares about you and your processes? We’re not code monkeys, we care about you

What are test-driven development (TDD) frameworks? 

Frameworks include the various tools and code libraries that help developers shorten the time it takes them to write tests for their code.TDD can be used with or without frameworks, so developers should focus on nailing the process either way.

And if you need more context on TDD, it’s an Agile technical practice that improves the end quality of your software by coding and running functionalunit tests before writing a single line of code. The TDD cycle has three key components: 

  • Red: write a test, run it, and get a failing test

  • Green: write the code to meet the test functionality and expect it to pass

  • Refactor: rewrite the code to make it simpler and broken into smaller pieces.

The test-driven development cycle starts with a failing test, then the test passes, and developers refactor the code. Once the cycle ends, it starts again by testing a different feature.

Common frameworks that can be used when doing TDD

These commonly used libraries and testing frameworks might be helpful for programmers when writing tests in different programming languages:

Why is TDD a good idea for Agile teams?

Test-driven development is great for Agile teams that want to:

  • Provide working, modular, and simple code. The quality of your code can be measured in how well it performs and how easy it is to understand and make changes to it. Since TDD ensures your code is refactored, you’ll always have simple and modular code that performs as expected and is easy to modify.

  • Improve their team’s productivity. One of the biggest benefits of TDD is that it makes the source code modular and simple, helping developers act fast and efficiently. That means if you ever need to debug or make changes to a feature, it’ll be easier to find, edit, test, and update a single part of the code without worrying about affecting other functionalities.

  • Meet all client’s requirements. A software solution is successful if it meets all the client’s requirements. The best way to ensure that those requirements are met is by translating them into unit tests as part of the TDD process.

  • Have a high code coverage rate. You can make TDD stronger by mixing it with continuous integration (CI). That practice ensures you test the code before you include it in the code repository. If you code using TDD, your code coverage rate (the percentage of software that you tested) will be higher than without it. 

  • Increase return on investment (ROI). While TDD might be more expensive at first. The development costs are higher at the beginning due to the expenses related to writing tests. But the ROI is higher in the long run because editing and maintaining the code gets easier and faster.

  • Live by Agile principles. Embracing change to increase the quality of the end-product is a vital Agile principle. Testing usually leads to changes that increase the code quality. 

  • Document your code. Every time you run a unit test, you’re indirectly documenting your code. That makes your development team save time and increases the quality of your code repository. 

5 examples of when TDD is worth doing

Some people say that test-driven development is the only acceptable way to code. We disagree. While TDD is a great test method, doing it in every case might feel like a waste of time. Here are some scenarios in which doing TDD is the best way to configure your Agile software development lifecycle.

1. When you have a project with clear requirements

Working on a software project that has clear requirements makes TDD a natural approach to coding. If every functionality and feature is documented beforehand, the project will have fewer changes, so it’s a good idea to do test-driven development. 

For example, take a Google extension that needs to block notifications from apps for a period of time. 

The extension should let you choose the apps you need to block/allow, how long to block them for, and whether to change the color of the screen to dim, black, or white while blocking notifications. Creating unit tests of these simple actions is going to be pretty straightforward and will lead to increased software quality.

But when clients don’t necessarily know all the requirements, TDD can become a tedious process because, with every new change, QA Automation Engineers will need to develop a new test for programmers to code against. 

2. When you don’t have a pressing deadline

It takes time to write unit tests, test the code, refactor code, and repeat for every feature. If you have a short time to market, TDD might not be the best option since your developers will probably need to put time over other technical qualities and generate technical debt they’ll take care of in the future. However, if you don’t have a fixed schedule, you can use TDD to increase code quality while generating minimum technical debt.

3. When you’re launching a new feature

While it’s not too common to use TDD in brownfield projects (projects with pre-existing software) you can use it when developing a new feature on an existing app or software. The best way to do TDD is to define the requirements of the new feature, code the unit tests, run them, and begin the coding process. 

Once you finish, you can include the tested feature in the code repository. This type of scenario is common when you change software providers and the new team has to build new features with high quality, and low technical debt. 

However, this example might be a case of when using behavior-driven development vs test-driven development is a better approach.

4. When you’re working on greenfield projects

Greenfield projects, like prototypes, MVPs, or progressive web apps, offer the freedom to build the project from scratch. In these cases, doing TDD is the best way to guarantee that you’ll have working software as a final product, as well as clean, modular, and simple code. 

When doing TDD for greenfield projects, software developers can create features and test them as they go to ensure quality code. 

5. When practicing with code katas

TDD is a technique that takes time and practice to master. A great way to start familiarizing yourself and your team with TDD is by doing code katas. Katas are simple developing exercises that help you master skills as you test them in simple scenarios. 

Code katas help developers learn and strengthen their development skills as they attempt to do it by themselves.

Doing TDD in any of these scenarios will ensure quality code and large code coverage.

What to do if you’ve never used TDD before?

While many developers know and recognize its value, others think it’s a waste of time or simply too hard to implement.

“Sometimes, the TDD or Automation approach might not add a lot of business value so it gets deprioritized,” explains Juan Sinnott, NaNLABS QA Automation Engineer. “Not applying test-driven development in Agile is a choice related to short deadlines and not always a matter of knowledge. With TDD, developers need to complete each stage before moving on to the next one which takes time.”  

Here’s where TDD fails and how to address those challenges.

Common TDD pitfalls

  1. Prolonged development process. TDD makes teams more productive long-term. But the process of testing, writing, testing, and refactoring before moving on to the next feature, makes the development process slow.

  2. Steep learning curve. The most common TDD pitfall is underestimating that it’s hard to master. But once developers get the hang of it, they can’t deny the added value of coding with a test-first approach.

  3. Tedious to unblock tests. Developers are used to writing and testing as they go. Having to wait for a green test result before they can move forward can make Agile developers feel constantly blocked.

  4. Less open to changes. Since QA engineers write the unit tests from the beginning, every change in the requirements results in changes in the tests. So, engineers need to rewrite the tests, and developers need to write new code to pass the new tests.

TDD framework best practices

As you can see, TDD is not the easiest technical practice. Here are some ideas to implement test-driven development without any struggles: 

  1. Hire an experienced developer who can pass on this knowledge to your team

  2. Encourage your team to practice with code katas

  3. Get an extended Agile team to work alongside your developers and learn by doing and changing mindsets from “it’s too hard” to “it’s hard now but it won’t feel hard once I learn.” 

NaNLABS supports businesses like yours to augment your development team with a group of our developers and software engineers that are always up to date with Agile continuous improvement practices and software development industry trends.

In fact, we have an internal program called NaNLABS Trends where we analyze technologies, libraries, frameworks, and processes that help us improve our work. We make sure to share that knowledge internally and across clients. 

The standard market practice is to get the app up and running, creating a Jira board to keep track of tickets. Then, when they find the time to do it, choose a feature, and create unit tests. That can take them days, if not months, to test the feature. 

“When teams implement TDD, it usually allows a high coverage,” shared Juan Sinnott. “But when they run tests on-demand, the coverage is reduced. In the long run, it generates legacy code that is difficult to test.”

Ready to build your own custom software with a team that cares about you and your processes? We’re not code monkeys, we care about you

Let’s refactor!

Test-driven development is a great way to approach software development, but doing it all the time may not be absolutely necessary. This test-first method is a great idea when: 

  • You have clear requirements

  • There aren’t any pressing deadlines

  • Working on greenfield projects or developing new features

  • Practicing.

Since this can be a difficult practice to get acquainted with, augmenting your development team is a great option. Especially, if you need to work on streamlining your operation, debugging, reducing technical debt, developing an MVP, or learning to implement Agile technical practices. 

Ready to build your own custom software with a team that cares about you and your processes? We’re not code monkeys, we care about you

Frequently asked questions about test-driven development frameworks

  • Is TDD an Agile framework?

    No, test-driven development is not an Agile framework, but an Agile technical practice. TDD is how you configure your software development lifecycle rather than a set of test libraries. TDD can also be defined as a testing method. 

  • What is an example of TDD and BDD?

    Test-driven development and behavior-driven development are both approaches to software development. TDD focuses on writing and conducting unit tests before developers begin writing code. BDD focuses on testing the end-user behavior. 

    If you want to understand the differences between Test-driven development vs behavior-driven development, a good example is to imagine that you want to get from Miami to Orlando. 

    BDD would only test to check if you got safely from Miami to Orlando on said date. TDD would break the process into small unit tests like

    1. Select a transportation method and expect it to be a car.

    2. Check that the car has oil and expect it to be yes. 

    3. Check that the car has gas and expect it to be full. 

    4. Confirm that you have the address of your hotel when you arrive and expect it to be yes. 

    5. Leave Miami at 6:13 am and expect to be on time.

    6. Drive to Orlando from Miami and expect to arrive by 10 am. 

    You can only proceed once the previous test is green. Once all the tests pass, you can expect that the last one will also be green. If any requirements change, you’ll need to rewrite each unit test. Also, your unit tests can have as many conditions as you need. 

  • Is Selenium for TDD or BDD?

    Selenium is an open-source tool that allows you to run automated tests. You can use Selenium for either behavior or test-driven development.

  • Is Cucumber for BDD or TDD?

    Cucumber is a collaborative tool that helps you implement and improve your software development team’s performance by using behavior-driven development.

  • How do you write TDD in Java?

    TDD in Java follows the same usual process:

    1. Write a unit test

    2. Run the test and expect it to fail (red)

    3. Write the code and expect the test to pass (green)

    4. Refactor code to make it clean and modular

    5. Repeat with the following unit test

    But using Java as the programming language and frameworks like JUnit or Mockito.

More articles to read

Previous blog post



Why You Need Pair Programming For Your Next Agile Project

Read the complete article

Next blog post

Web Technologies


5 Powerful Test-Driven Development Tools (+ Tutorial)

Read the complete article