Test Driven Development: How and Why

Test Driven Development(TDD) is a very useful approach towards code development. It keeps the developer from having to second guess every piece of code he writes.

The TDD workflow goes like this:

First, you write a block of code. Next, write a unit test for that block of code and ensure it passes. If there are any issues, refactor.

This workflow also makes your design more intentional as it elucidates what the code is suppose to do.

Each unit test is a test case and a grouping of tests makes up a test suite

Unit tests should run on memory and not rely heavily on databases or even filesystems. 

It comes down to this: the behavior of the code is serving the original purpose intended by the developer. If there is suppose to an exception then code should raise it.

Reduce risk

it is the manifestation of the DevOps concept of 'Shifting Left. By discovering any issues to the left side of the Software Development Lifecycle(SDLC), the cost of fixing it is reduced. Unit tests will guard against committing(and eventually pushing) a broken build unknowingly to a common code repository.

Maintenance

Prevents code regression. Unit tests protects code from slowly regressing as components are adding to it. The core functionality of that unit of code is protected by the tests. You can be assured fixes done elsewhere in the code have no side-effects. In the event that there are side-effects, it allows for quick detection and remediation.


Unit of Code under Test

Example: Simple function which takes user input and decides what to do with it  - Let's check that behavior of code is consistent with the value it receives

Here we are testing a unit of code that is a function. It takes user input with Python's input command and should correctly locate a file as per the input.





































Test Case with Test Double: Using mock to simulate user input

Here we have a test case written for the abovementioned function.

This test case is trying to assert the behavior of the function when it receives valid inputs, it should be able to reach a specific file within the inputs.

As unit tests should not be dependent on external resources, we are creating a test double - a mock to simulate user input. In this instance, we are generating a temporary file and folder which gets cleaned up after test. 

The mock test double is created using the Python decorator @mock.patch.




















The tests are passing. Indicating that the code is responding as intended to user inputs.


A mock is one type of test double. It has a behaviour of its own and has to be correctly implemented to run the test case. In this case, the mock_input.side_effect attribute had to be used for passing the test values to the overriden input functions in Startup.py. 

There are other ways to create test doubles such as stubs, spies, fakes, dummies; what test double to use depends on needs of the test.


Conclusion

It might seem like there is more work initially, but its pay off is far exceeds the extra work. By testing as you build, you have a peace of mind that code written is working before moving on. 

TDD is not a silver bullet to detecting issues in code. But it can really go a long way to helping the developer cope with process of development and testing; not just the primary developer, but anyone who is inheriting the source code.



Comments

Post a Comment

Popular posts from this blog

Using Git pre-commit hooks: Automated Testing of Code with Python Unit Tests

Image
This post show how a pre-commit git hook is implemented. The git hook is used to trigger a script which runs the unit test using my conda environment. Using pre-commit hooks will prevent commit code with issues into your local repo and is preventing the developer from eventually pushing a broken build into the a remote repository This is in tandem with a test driven approach, instead of having to run my tests separately, then commit, I have only need to commit. Personally, I find them to be really useful. For example, you can use them stop commits if files contain certain confidential data. The pre-commit hook can be bypassed, but that's not what this post is about. We as developers need to be assured that we are not messing up every step of the way.  Using pre-commit hooks can take some that pressure off as we work by automating the code testing as we work. Do note that this works on a per-commit basis. It does not retrospectively check for for previous commits. Steps to create an...
Read more

Five Things I Wish I Knew When Starting with Python

Image
  There are definitely more than five things, but here are five that really struck me. 1. Create specific environment for project and only install the required packages By creating a virtual environment, Python libraries specific to a project remain within that environment. Any dependencies(packages) installed in one environment is isolated from another. This might prevent version clashes between packages or unknowingly using a different package version across projects. Creating project specific environments is good house-keeping. This should be done even before   any code gets written.  You can create a virtual environment with Python Virtual Environment or with Conda. The example below is listing all available conda environments and creating a new one with conda create . Tangibly, the environment is a folder location on a drive. That you can activate with a command to manage 2. List/Dictionary Comprehensions  What would life be without List/Dictionary Comprehensi...
Read more