Unit Testing Fundamentals

Unit tests form the foundation of test automation. They verify the smallest parts of software in isolation and deliver fast feedback when something breaks. When done well, unit tests prevent costly bugs and build confidence in your code.

In a Nutshell

• Unit tests verify individual functions, classes, or methods in isolation.
• They’re fast, repeatable, and provide immediate feedback.
• Good unit tests are independent, deterministic, and focused on a single behavior.
• They form the broad base of the test pyramid.

Definition

A unit test verifies the smallest testable piece of software in isolation. You typically call a function or method with defined inputs and compare the result against an expected value. Dependencies like databases, file systems, or external services are replaced with stubs or mocks, so the test exercises only the unit’s logic.

Structure of a Unit Test

A classic unit test follows the Arrange-Act-Assert pattern:

1. Arrange: Prepare inputs, objects, and dependencies.
2. Act: Execute the function being tested.
3. Assert: Verify the result against your expectation.

Best Practices

• One test, one concept: Each test should verify exactly one behavior.
• Independence: Tests must not depend on each other.
• Determinism: Identical inputs must always produce identical results.
• Clarity: Test names describe the behavior, not the method.
• Use mocks sparingly: Too many mocks can hide real bugs.
• Don’t skip edge cases: Test empty inputs, null values, and boundary conditions.

Real-World Example: Price Calculation with Discount

import unittest

def calculate_price(base_price, discount_percent):
    if base_price < 0:
        raise ValueError("Preis darf nicht negativ sein")
    if discount_percent < 0 or discount_percent > 100:
        raise ValueError("Rabatt muss zwischen 0 und 100 liegen")
    return base_price * (1 - discount_percent / 100)

class TestPriceCalculation(unittest.TestCase):
    def test_no_discount(self):
        self.assertEqual(calculate_price(100, 0), 100)

    def test_with_discount(self):
        self.assertEqual(calculate_price(100, 20), 80)

    def test_full_discount(self):
        self.assertEqual(calculate_price(100, 100), 0)

    def test_invalid_price(self):
        with self.assertRaises(ValueError):
            calculate_price(-10, 10)

    def test_invalid_discount(self):
        with self.assertRaises(ValueError):
            calculate_price(100, 110)

if __name__ == '__main__':
    unittest.main()

Strengths and Weaknesses

Strengths

• Fast feedback: Unit tests run in milliseconds to seconds.
• Pinpoint failures: Issues get traced directly to a specific unit.
• Refactoring confidence: Existing tests tell you whether refactors broke anything.
• Better code structure: Testable code is typically better modularized.
• Living documentation: Tests show how a unit should be used.

Weaknesses

• Upfront effort: Tests must be written and maintained.
• Limited scope: Complex UI logic or external systems are hard to test in isolation.
• False confidence: High code coverage doesn’t guarantee test quality.
• Maintenance burden: Poorly written unit tests slow development.

Key Exam Topics

• Definition and purpose of unit tests.
• Arrange-Act-Assert pattern.
• Difference between unit tests and integration tests.
• Strengths and limitations of unit tests.
• Common frameworks: JUnit, NUnit, pytest, Jest.

Common Exam Questions (Short Answers)

1. What is a unit test? A test that verifies the smallest testable unit in isolation.

2. What pattern is commonly used for unit tests? Arrange-Act-Assert.

3. What is a mock? A substitute object for a dependency that simulates controlled behavior.

4. Why should unit tests be deterministic? So identical inputs always produce the same result, making tests reliable.

5. Name one advantage of unit tests when refactoring. They immediately show whether a change breaks existing behavior.

Next in the Software Testing Learning Path

The next article covers Integration Testing Fundamentals — how to test the interaction of multiple components.

Key Resources

1. https://martinfowler.com/bliki/UnitTest.html
2. https://testing.googleblog.com/2015/04/just-say-no-to-more-end-to-end-tests.html
3. https://en.wikipedia.org/wiki/Unit_testing