Developing JavaScript - When should I start making unit tests? [closed]

Question

I've started writing a JavaScript application as a personal project. I am hoping to learn and use unit testing for this project. I do not have much experience in writing unit tests, but I have read that Jasmine would be a good library to help me achieve this.

With that said, I was a bit overzealous in my initial coding spree. I had an idea and ran with it. As such, the structure of my application was and continues to be not as OO as I would prefer. This has lead me down the path of multiple, large refactors. I've found that refactoring in a weakly-typed language leaves me especially prone to bug-reentrance.

The fact that I am having to go back and address bugs that I've reintroduced makes me yearn for unit tests. By contrast, however, the fact that I am reworking the foundation of my codebase so much still causes me to hesitate. I do not want to create unit tests for my project only to then decide that more restructuring (which will deprecate my tests past the point of 'correcting an error') is needed.

Is this a common concern? I feel like there will be a point in time where my 'foundation' will be stable enough to write tests for it... but that makes the tests sound so much less appealing.

Answer 1

I would consider treating your current codebase as "experimental" or as a "prototype" - as in, something that you would mostly discard.

If you plan on refactoring your codebase, it would probably be a good idea to introduce unit tests either before you refactor or for the refactored code.

The benefits of writing tests for the current codebase are quite obvious: You can run your refactored codebase against them to verify the functionality. You will probably need to restructure your tests somewhat as well while you are refactoring, but that's normal.

What you shouldn't do while rewriting the tests is delete them. Try to keep all the final assertions in each of your test the same, while replacing how the test otherwise works. This way you should be able to keep track of what you are testing better, and that the new functionality still does the same job.

Of course if you wrote your original code in a non-OO fashion, it may be difficult to test it well. In this case, I would suggest choosing to either write higher level tests (functional tests) for your original code, or to write your refactored code using a TDD type approach.

Using functional tests, you can have test coverage for the main functionality of your application. You won't have as fine grained tests as with unit tests, but you could write the tests more easily and would not need to modify them as much in the end. You could use a tool like Selenium for this.

With the TDD approach you would probably have the least amount of work. You would ensure good test coverage for the newly written code, but you would have to manually verify the code works the same way as the old one did.