Unit Testing: Theory, Purpose, Procedures & Current Applications

July 19, 2023 Waseem Mehmood

What is the theory of Unit Testing?

The theory of unit testing is a fundamental concept in software development that aims to ensure the correctness and reliability of individual units or components of code. Unit testing is a crucial practice in the larger context of software testing, and it follows the principles of the Test-Driven Development (TDD) approach. The goal is to test all units of code and ensure that they work as expected and without errors.

The main principles and concepts behind unit testing are as follows:

Unit of Testing: A unit in unit testing refers to the smallest testable part of the code, typically a function, method, or procedure. The goal is to isolate and test the individual units in isolation from the rest of the codebase to ensure their correctness independently.
Test Cases: Test cases are sets of input values and expected outcomes that represent different scenarios for the unit under test. These cases validate whether the unit behaves as expected and produces the correct results.
Automated Testing: Unit testing is typically automated, meaning that test cases are written as code and executed automatically as part of the build and deployment process. This automation allows for frequent and consistent testing during development.
Isolation: During unit testing, units are tested in isolation from the rest of the application. Dependencies are often mocked or stubbed to create a controlled environment, focusing solely on the behavior of the unit being tested.
Fast and Frequent Testing: Unit tests are designed to be fast and efficient, allowing developers to run them frequently during development. This immediate feedback helps catch bugs early and maintain the quality of the codebase.
Code Coverage: Code coverage measures the percentage of code exercised by unit tests. The goal is to achieve high code coverage, ensuring that most of the code is tested and reducing the chances of untested code paths.
Regression Testing: Unit tests act as regression tests, ensuring that new code changes do not inadvertently break existing functionality. When a test fails after a code change, it indicates a regression that needs to be addressed.

Unit testing is a critical part of the software development process, promoting code reliability, maintainability, and agility. It allows developers to build and modify code with confidence, knowing that they have a suite of tests to validate the functionality of individual components. Unit tests, when combined with integration tests and other testing practices, contribute to the overall quality assurance and stability of software applications.

What’s the Key Purpose of Unit Testing?

The key purpose of unit testing is to ensure the correctness and reliability of individual units or components of code in isolation. Unit testing is a fundamental practice in software development and serves several important purposes:

Detecting Bugs Early: Unit tests help identify and catch bugs and errors in the code at an early stage of development. By testing individual units in isolation, developers can identify and address issues before they propagate to other parts of the application.
Isolating Defects: Unit testing allows defects to be isolated to specific units of code. When a test fails, it indicates that the unit being tested has an issue, making it easier to pinpoint and fix the problem.
Verifying Functionality: Unit tests validate that each unit of code functions as intended and produces the expected output for a given set of inputs. This ensures that the code behaves as expected and meets the requirements.
Refactoring with Confidence: Unit tests provide a safety net when refactoring or modifying code. Developers can refactor code with confidence, knowing that if their changes break existing functionality, the unit tests will detect it.
Promoting Code Quality: Writing unit tests encourages developers to write clean, modular, and testable code. It helps improve code quality and readability by enforcing good coding practices.
Facilitating Collaboration: Unit tests act as a form of documentation, providing a clear specification of how units are expected to behave. This can help new team members understand the codebase and collaborate more effectively.
Continuous Integration and Deployment: Unit testing is a crucial part of continuous integration and deployment pipelines. Automated unit tests ensure that changes are continuously validated, reducing the risk of introducing defects into production.
Reducing Debugging Time: Having unit tests in place makes it easier and faster to identify the root cause of a bug. Instead of manually debugging through the entire application, developers can focus on the specific unit that failed the test.
Increasing Software Maintainability: As projects grow in size and complexity, maintaining and enhancing code can become challenging. Unit tests provide a safety net during maintenance, enabling developers to confidently make changes without introducing new defects.

By achieving these goals, unit testing contributes to the overall quality, reliability, and maintainability of software applications. It is an essential practice in modern software development methodologies like Test-Driven Development (TDD) and plays a vital role in building robust and successful software products.

How To Perform Unit Testing in JavaScript?

Performing unit testing in JavaScript involves using testing frameworks and tools to write and execute tests for individual units of code. Here’s a step-by-step guide on how to perform unit testing in JavaScript:

Choose a Testing Framework: Start by selecting a JavaScript testing framework that suits your project’s needs. Some popular testing frameworks for JavaScript include Jest, Mocha, Jasmine, and Ava. Jest is a widely-used framework with built-in assertions and utilities, making it a good choice for most projects.
Install Dependencies: Once you have chosen a testing framework, install it and any necessary dependencies using npm (Node Package Manager). For example, if you’re using Jest, you can install it by running the following command in your project directory:
Write Test Cases: Create test files for your JavaScript code, usually placed in a separate directory (e.g., tests or __tests__). Each test file should correspond to a module or file you want to test. Write individual test cases within the test files to cover different scenarios and functionalities.
Import the Module: In each test file, import the module or function you want to test using require or ES6 import syntax.
Write Test Cases: Use the testing framework’s assertion methods to write test cases. For example, in Jest, you can use expect to test if a value matches an expected result:
Run Tests: To execute the unit tests, run the testing framework from the command line. For example, to run tests with Jest, use:

This will run all the test files in the specified test directory and report the test results.
Evaluate Test Results: Review the test results to see if all the test cases pass. If a test fails, investigate the issue, fix the code, and rerun the tests until all tests pass successfully.
Continuous Integration (Optional): For larger projects, consider integrating unit testing into your continuous integration (CI) workflow. This ensures that tests are automatically executed whenever code changes are pushed, helping catch regressions early in the development process.

By following these steps, you can perform unit testing in JavaScript to ensure the correctness and reliability of your codebase. Consistent unit testing contributes to higher code quality, easier maintenance, and faster development cycles.

Test Case Scenarios for Unit Testing in JavaScript using Jest:

Developed by Meta (Facebook), Jest stands out as a leading JavaScript testing framework renowned for its simplicity and versatility in automating test scenarios. While Jest excels at testing the JavaScript implementations of web applications, particularly those built with React, it also seamlessly supports unit testing in other popular frameworks like Angular, Vue, and Node.js.

Let’s consider a simple example scenario where we want to test a function that calculates the total price of items in a shopping cart.

Test Case: Calculate the Total Price for Empty Cart
- Description: Ensure that the function correctly handles an empty shopping cart and returns a total price of 0.
- Test Data: An empty array representing an empty cart.
- Expected Result: The function should return 0 as the total price.
Test Case: Calculate the Total Price for a Cart with Items
- Description: Test the function with a cart containing multiple items with different prices.
- Test Data: An array of items with their respective prices: [{ name: 'Item 1', price: 10 }, { name: 'Item 2', price: 15 }, { name: 'Item 3', price: 20 }]
- Expected Result: The function should return the sum of item prices: 45.
Test Case: Calculate the Total Price for Negative Item Prices
- Description: Ensure that the function correctly handles negative item prices.
- Test Data: An array of items with negative prices: [{ name: 'Item 1', price: 10 }, { name: 'Item 2', price: -5 }, { name: 'Item 3', price: 20 }]
- Expected Result: The function should return the sum of item prices excluding the negative price item: 30.
Test Case: Calculate the Total Price for Cart with Invalid Data
- Description: Test the function with a cart containing invalid data (e.g., missing prices).
- Test Data: An array of items with missing or invalid price values: [{ name: 'Item 1', price: 10 }, { name: 'Item 2' }, { name: 'Item 3', price: 20 }]
- Expected Result: The function should handle missing or invalid price values and return the sum of valid item prices: 30.
Test Case: Calculate the Total Price for Large Cart
- Description: Test the function with a large cart containing many items.
- Test Data: An array of 100 items with random prices.
- Expected Result: The function should accurately calculate the total price for the large cart without performance issues.

By writing these test cases using Jest, you can ensure that the calculateTotalPrice function behaves as expected under different scenarios and that it meets the specified requirements. Running these test cases with Jest will provide feedback on whether the function passes all the tests and correctly handles different input data and edge cases.

Test Case Scenarios for Unit Testing in JavaScript using Mocha:

Mocha is another top JavaScript testing framework that is designed for testing apps running in Node.js. It supports various types of testing such as unit, integration, and end-to-end testing.

Let’s consider a simple example scenario where we want to test a function that converts temperatures from Celsius to Fahrenheit.

Test Case: Convert Temperature from Celsius to Fahrenheit
- Description: Ensure that the function correctly converts temperatures from Celsius to Fahrenheit.
- Test Data: Temperature value in Celsius (e.g., 25°C).
- Expected Result: The function should return the equivalent temperature in Fahrenheit (e.g., 77°F).
Test Case: Convert Negative Temperature from Celsius to Fahrenheit
- Description: Test the function with a negative temperature value in Celsius.
- Test Data: Negative temperature value in Celsius (e.g., -10°C).
- Expected Result: The function should correctly convert the negative temperature to Fahrenheit (e.g., 14°F).
Test Case: Convert Temperature with Decimal Values
- Description: Test the function with a temperature value containing decimals.
- Test Data: Temperature value in Celsius with decimals (e.g., 30.5°C).
- Expected Result: The function should accurately convert the temperature to Fahrenheit (e.g., 86.9°F).
Test Case: Convert Temperature with Invalid Input
- Description: Test the function with invalid input (e.g., non-numeric value).
- Test Data: Invalid temperature value (e.g., “abc”).
- Expected Result: The function should handle invalid input and return an error or an appropriate default value.
Test Case: Convert Temperature with Large Values
- Description: Test the function with large temperature values.
- Test Data: Extremely high or low temperature values in Celsius (e.g., 1000°C, -1000°C).
- Expected Result: The function should correctly convert large temperature values to Fahrenheit.

By writing these test cases using Mocha, you can ensure that the convertCelsiusToFahrenheit function behaves as expected under different scenarios and that it accurately converts temperatures. Running these test cases with Mocha will provide feedback on whether the function passes all the tests and handles various input data and edge cases correctly.

How To Perform Unit Testing in Python?

Performing unit testing in Python involves using testing frameworks and tools to write and execute tests for individual units of code. Here’s a step-by-step guide on how to perform unit testing in Python:

Choose a Testing Framework: Start by selecting a Python testing framework that suits your project’s needs. Some popular testing frameworks for Python include unittest, pytest, and nose. Unittest is Python’s built-in testing framework, while pytest and nose offer additional features and flexibility.
Install Dependencies: Once you have chosen a testing framework, install it and any necessary dependencies using pip (Python Package Installer). For example, if you’re using pytest, you can install it by running the following command:

pip install pytest
Write Test Cases: Create test files for your Python code, typically placed in a separate directory (e.g., tests). Each test file should correspond to a module or file you want to test. Write individual test cases within the test files to cover different scenarios and functionalities.
Import the Module: In each test file, import the module or function you want to test using the import statement.
Write Test Cases: Use the testing framework’s assertion methods to write test cases. For example, in pytest, you can use assert to test if a value matches an expected result:
Run Tests: To execute the unit tests, run the testing framework from the command line. For example, to run tests with pytest, use:

This will discover and run all the test files in the specified test directory and report the test results.
Evaluate Test Results: Review the test results to see if all the test cases pass. If a test fails, investigate the issue, fix the code, and rerun the tests until all tests pass successfully.
Test Coverage (Optional): For larger projects, consider using test coverage tools to assess how much of your code is covered by tests. Tools like coverage.py can help identify areas of your code that are not being tested.

By following these steps, you can perform unit testing in Python to ensure the correctness and reliability of your codebase. Consistent unit testing contributes to higher code quality, easier maintenance, and faster development cycles.

Test Case Scenario for Unit Testing in Python Using Unittest:

Let’s consider a simple example scenario where we want to test a function that calculates the area of a rectangle.

Test Case: Calculate the Area of a Rectangle with Positive Length and Width
- Description: Ensure that the function correctly calculates the area of a rectangle when provided with positive length and width values.
- Test Data: Length = 5, Width = 10
- Expected Result: The function should return 50 as the area of the rectangle.

Test Case: Calculate the Area of a Rectangle with Negative Length
- Description: Test the function when provided with a negative length value.
- Test Data: Length = -5, Width = 10
- Expected Result: The function should raise a ValueError since a negative length is not valid for a rectangle.

Test Case: Calculate the Area of a Rectangle with Zero Width
- Description: Test the function when provided with a rectangle with zero width.
- Test Data: Length = 5, Width = 0
- Expected Result: The function should return 0 as the area since a rectangle with zero width has no area.

Test Case: Calculate the Area of a Rectangle with Decimal Values
- Description: Test the function when provided with rectangle dimensions containing decimal values.
- Test Data: Length = 2.5, Width = 3.5
- Expected Result: The function should correctly calculate the area as 8.75.

In this example, we are using the unittest framework to write test cases for a function called calculate_area that calculates the area of a rectangle. The test cases cover different scenarios, including positive and negative values for length and width, zero width, and decimal values. The assertEqual and assertRaises methods from unittest.TestCase are used to verify the expected results of each test case.

To run the tests, you can use the unittest test runner. Save the test cases in a separate file (e.g., test_rectangle.py), and then run the following command in your terminal:

The unittest test runner will discover and execute all the test cases in the specified test file and provide the test results.

Test Case Scenario for Unit Testing in Python Using Pytest:

Let’s consider a simple example scenario where we want to test a function that calculates the factorial of a number.

Test Case: Calculate the Factorial of a Positive Number
- Description: Ensure that the function correctly calculates the factorial of a positive number.
- Test Data: Number = 5
- Expected Result: The function should return 120 as the factorial of 5.

Test Case: Calculate the Factorial of Zero
- Description: Test the function when provided with the number 0.
- Test Data: Number = 0
- Expected Result: The function should return 1, as the factorial of 0 is defined as 1.

Test Case: Calculate the Factorial of a Negative Number
- Description: Test the function when provided with a negative number.
- Test Data: Number = -5
- Expected Result: The function should raise a ValueError since factorial is not defined for negative numbers.

Test Case: Calculate the Factorial of a Large Number
- Description: Test the function with a large number to check performance and accuracy.
- Test Data: Number = 10
- Expected Result: The function should correctly calculate the factorial of 10.

In this example, we are using the pytest framework to write test cases for a function called calculate_factorial that calculates the factorial of a number. The test cases cover different scenarios, including positive, zero, and negative values, as well as a large number for performance testing. The assert statement from pytest is used to verify the expected results of each test case.

To run the tests, save the test cases in a separate file (e.g., test_factorial.py) and run the following command in your terminal:

The pytest test runner will discover and execute all the test cases in the specified test file and provide the test results.

Conclusion

If you want to get to clean, bug-free code faster, unit testing is will get you there. It basically tells you where the problem lies in the code. Yes, your developers will have to spend extra hours fixing bugs, but it will be worth it in the end.