There are many stories about unit testing. Developers sometimes say that they don’t write tests because they write a good quality code. Does it make sense, if no one is infallible?.
At studies only a few teachers talk about unit testing, but they only show basic examples of unit testing. They require to write a few tests to finish final project, but nobody really teaches us the importance of unit testing.
I have also always wondered what benefits can it bring. As time is a really important factor in our work it often happens that we simply resign of this part of process development to get “more time” rather than spend time on writing stupid tests. But now I know that it is a vicious circle.
Customers requierments does not help us. They put a high pressure to see visible results not a few statistics about coverage status. None of them cares about some strange numbers. So, as I mentioned above, we usually focuses on building new features and get riid of tests. It may seem to save time, but it doesn’t.
In reality tests save us a lot of time because we can identify and fix bugs very quickly. If a bug ocurrs because someone’s change we don’t have to spend long hours trying to figure out wgat is going out. That’s why we need tests.
It is especially visible in huge open source projects. FOSSASIA organization has about 200 contributors. In OpenEvent project we have about 20 active developers, who generate many lines of code every single day. Many of them change over and over again as well as interfere with each other.
Let me provide you with a simple example. In our team we have about 7 pull requests per day. As I mentioned above we want to make our code high quality and free of bugs, but without testing identifying if pull request causes a bug is very difficult task. But fortunately this boring job makes Travis CI for us. It is a great tool which uses our tests and runs them on every PR to check if bugs occur. It helps us to quickly notice bugs and maintain our project very well.
What is unit testing?
Unit testing is a software development method in which the smallest testable parts of an application are tested
Why do we need writing unit tests?
Let me point all arguments why unit testing is really important while developing a project.
- To prove that our code works properly
If developer adds another condition, test checks if method returns correct results. You simply don’t need to wonder if something is wrong with you code.
- To reduce amount of bugs
It let you to know what inputs params’ function should get and what results should be returned. You simply don’t write unused code
- To save development time
Developers don’t waste time on checking every code’s change if his code works correctly
- Unit tests help to understand software design
- To provide quick feedback about method which you are testing
- To help document a code
How to write unit test in Python
In my work I write use tests in Python. I am going to share my sample code with you now
- Import module unittest
- Choose function to test
- Write unit test
class TestPagesUrls(OpenEventTestCase): def setUp(self): self.app = Setup.create_app() def test_if_urls_exist(self): """Test all urls via GET method""" with app.test_request_context(): for rule in app.url_map.iter_rules(): if excluded_paths(rule): status_code = self.app.get(request.url[:-1] + str(rule).replace('//', '/'), follow_redirects=True).status_code self.assertTrue(status_code in [200, 302, 401])
I want to check if all views exist but it required a lot of time. That’s why I wonder I how to avoid writing similar tests. Finally, based on our list of routes I am able to write test which checks code’s status on every page.
If some of them response returns status_code different than 200, 302 or 401, test fails.This results means that somethings is wrong. Simple, isn’t it ? Try to test it manually…. This one short test cover about 40 use cases…
This example shows an incredible value of unit tests! If developer makes a bug in response he receives an error that something is wrong with a view. Travis CI allows to reject all wrong pull requests and merge only these which fulfill our quality requirements.
Fixing error is one part but finding a bug is even harder task. But an ability to detect bug on early stage of process development reduces cost of software.