This article is going to be fun, as we are going to see how a simple technique can make your JavaScript code elegant and highly testable.

Writing testable code is very important. It allows you to quickly integrate automated testing in your software. Adding automated testing will prevent lots of bugs and issues while making your software more maintainable.

Unfortunately, most developers tend to think that writing testable code is very difficult. Let's see how easier it gets in just 3 step process.

4 common mistakes that make code hard to test

Always remember this thumb rule when writing software: Test-driven development should make your code simpler, not more complicated. It means that if the code is hard to test, it needs refactoring.

Adding multiple responsibilities to a single piece of code.

Preferred use of impure functions.

Tightly coupled code.

Not writing code before writing actual implementation.

The simple quick technique we are going to see will make you love to write testable code in JavaScript

Here's how, step by step:

Step 1: Break down your code

This is the most important step in the entire process.

Think of every function as a single unit of code. Always remember these two thumb rule:

No function should have more than 25 lines.
Every function should do only one thing.

Follow below steps to decompose a large piece of code:

Divide your problem (application feature) into small simple steps.

Convert steps into very small independent pure functions. Remember that these functions will act as independent atomic units of your application.

If you notice above code, the single processStudentList function has multiple responsibilities. It should be broken down to simple tasks.

The above code is so flexible that it can be tested so easily independently. This beauty of composition. It makes your code self-documenting and highly testable.

Step 2: Always prefer pure functions

Pure functions are those functions which when given an input, always returns same output.

The pure function does not have any side-effects which means it cannot do these things:

Directly modifying objects passed in parameters.

Making network requests.

Calling functions which are not pure.

Returning unpredictable output such as random number, date, timestamp etc.

The main advantage of using pure function is that it makes your code very predictable, testable and prevents bug. All functions in above code are pure.

Step 3: Always write tests first

Always write tests first. This is where our first step does the magic.

Since we are writing small pure functions, writing tests for them becomes very easy and quick task.

First write tests and make sure it fails.

Then write the implementation just to pass the test.

Follow above steps again.

Refactor the code if required and run test again to make sure its working perfectly.

A Guaranteed Method For Writing Testable Code In JavaScript

This article is going to be fun, as we are going to see how a simple technique can make yo

The all-in-one writing platform.

Write, publish everywhere, see what works, and become a better writer - all in one place.