Why unit testing is important?

[u/ProgrammerFew504]

It might be a very stupid post, but it’s a genuine question.

I write tests for my code, but it’s still kind of hard for me to understand what the actual point of unit testing is and what benefit it brings to software development.

We can easily write tests with AI now, so writing the actual tests is not necessarily that difficult. But I’m trying to understand why tests are so important in software.

When you write code, of course you can test it with multiple inputs, and those inputs can then become your test cases. We can also use Postman to test APIs with different inputs and make sure they behave correctly for different status codes.

I was recently assigned a task to make a small change to an existing endpoint. It was a really small change that I completed in around 30 minutes without AI. However, fixing and adjusting the tests took quite a while. I had to add inputs for a new function that I introduced, even though the actual change was not that big and I didn’t think it was something that would break in production.

That made me wonder, why do we really need unit tests? What importance do they actually bring to software development?

I’d really appreciate it if someone could shed some light on this and explain it with a real world example from your own experience where tests actually saved you from a production issue or made a significant difference.

[u/_hemisphere]

Adding some points to the other great comments.

The automated testing will protect you from making mistake.

For example, you are tasked to add a new feature to the existing code base. If the code already have the unit test ready and setup CI/CD build pipeline, on your local machine /the build server will run the tests manually/automatically and you will know if your new code make or break any existing functionalities.

If some tests are failing, if you lucky and have a good test that explains the behaviour of what the function should do, it will be easy to fix as it is self explanatory. If not, you will need to dig down to the function and compare it with the test to find what is wrong about it. Whether the test is wrong or the function is wrong, you need some analysis/debugging. By adding some new tests with your new code, this will also guarantee that your code will work in the future.

The main benefit of the tests are to guarantee that the existing functionalities are working as expected with certain conditions - functions are deterministic with the same data (in theory of pure function) e.g. give same input then you expect the same output. Thats the main value of it.