I've been trying to jump on the TDD bandwagon for some time now, and it's been going well except for one crucial thing, normally what I end up doing is Test After Development.
I need a mental shift and am wondering how did you force yourself to write tests first?
In layman's terms, Test Driven Development (TDD) is a software development practice that focuses on creating unit test cases before developing the actual code. It is an iterative approach that combines programming, the creation of unit tests, and refactoring.
Although TDD is popular, few shops practice it: A survey of developers published in September 2020 found that although 41% of the respondents said their organizations have fully adopted TDD, only 8% said they write tests before code at least 80% of the time, which is the definition of TDD.
TDD is not dead in 2022. It will never be dead because there will always be projects where developers can use TDD effectively. Today and in the future, developers will want to make sure their code is not broken and works properly. By writing tests first, developers can see if they are on the right track or not.
The mental shift for me was realizing that TDD is about design, not testing. TDD allows you to reason critically about the API of the thing you're constructing. Write the tests first and it's often very clear what API is most convenient and appropriate. Then write your implementation.
Of course you should be writing tests after too (regression tests, integration tests, etc). TDD often produces good design, but not necessarily good testing code.
A big moment came for me with TDD when I read a certain quote (I can't recall where) that the moment of triumph for a test is the moment when the test changes from red to green.
This is probably all stuff you've read before, but unless I start with a failing test, and it becomes a passed test, that's when I reap the huge psychological benefits. It feels good to change from red to green. And if you are consistent with delivering that moment to yourself, it becomes addictive, and then much easier to make yourself do.
But the trick for me was to isolate that moment and revel in it.
Once i started leveraging dependency injection, my classes became smaller and more specialized which allowed me to write simple unit tests to confirm they worked. Given the limited number of tests i knew my class had to pass to work, the goal of my TDD effort became more clear. It was also easier to identify which classes required integration tests due to dependencies on external resources and which classed required unit tests that injected mock/stub/fake objects into the SUT to narrow the focus of my test.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With