Unit Testing Basics: Why It Matters & How to Test

When developers build software, writing code is only one part of the job. The real challenge is making sure that the code continues to work correctly as the application grows and changes.

This is where unit testing becomes valuable.

Unit testing helps developers check small pieces of code independently, catch problems early, and reduce the risk of existing functionality breaking after new changes.

What Is Unit Testing?

Unit testing is the process of testing the smallest individual piece of code, such as a function, method, or small module.

For example, consider this JavaScript function:

function add(a, b) {

return a + b;

}

If we call:

add(10, 20)

we expect the result to be 30.

Instead of testing the entire application, a unit test checks only the add() function and confirms whether it returns the expected result.

The basic flow is simple:

Input → Function → Actual Result → Compare With Expected Result → Pass or Fail

Why Is Unit Testing Important?

Unit tests give developers fast feedback during development.

They help teams:

Find bugs early: Logic problems can be identified closer to where they were introduced.
Verify functionality: Developers can confirm that each function behaves as expected.
Prevent regression: Tests can reveal when a new code change breaks something that previously worked.
Improve code quality: Small, testable functions usually encourage cleaner and more maintainable code.

Unit testing becomes especially useful as applications grow and multiple developers work on the same codebase.

How to Write a Unit Test

A simple way to structure unit tests is the Arrange, Act, Assert (AAA) pattern.

Arrange: Prepare the test data.

const a = 10;

const b = 20;

Act: Run the function.

const result = add(a, b);

Assert: Verify the result.

expect(result).toBe(30);

Using Jest or Vitest-style syntax, the complete test may look like:

test("should add two numbers", () => {

expect(add(10, 20)).toBe(30);

});

A good unit test should not focus only on normal inputs. Developers should also consider boundary values, invalid inputs, and expected error conditions.

Unit Testing vs Other Testing Types

Unit testing checks individual pieces of code, while other testing methods focus on different levels of application quality.

Smoke Testing is a quick check of the application's most important features after a new build. For example, testers may verify login, cart, and checkout before starting detailed testing.

Sanity Testing focuses on a particular change or bug fix. If the password-reset feature was fixed, sanity testing verifies whether that specific flow now works correctly.

Regression Testing checks whether a new change has affected functionality that previously worked.

For example, after changing discount calculations, testers may recheck the cart, tax, payment, and checkout processes.

End-to-end testing goes even further by checking complete user journeys, while unit testing focuses on individual functions.

Final Thoughts

Unit testing does not need to be complicated.

Start with one function, identify the expected behaviour, and write a clear test for it. Then gradually include positive, boundary, invalid, and error scenarios.

Remember the three basics:

Test small units independently.
Use Arrange → Act → Assert.
Test to prevent bugs and regressions.

Combining unit testing with smoke, sanity, regression, and end-to-end testing can help development teams build more reliable and maintainable software.