Testing Methodology (see Testing & Quality Disciplines)

## What this is about **Unit testing** means writing small programs (tests) that automatically check that a piece of your production code (a *unit* — usually one class or method) behaves correctly, without a human clicking through the app. **JUnit** is the de-facto standard *test framework* for Java: it provides the vocabulary (annotations) for marking which methods are tests, and a *test runner* that discovers and executes them, then reports pass/fail. **JUnit 5** is the current major version. It is actually three pieces: **JUnit Platform** (the engine launcher that IDEs/Gradle/Maven talk to), **JUnit Jupiter** (the new programming model — the annotations and assertions you write against), and **JUnit Vintage** (a compatibility engine that runs old JUnit 4 tests). When people say "JUnit 5" in code they almost always mean **Jupiter**, in package `org.junit.jupiter.api`. ## A minimal test ```java import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; class CalculatorTest { @Test void addsTwoNumbers() { Calculator calc = new Calculator(); // Arrange int result = calc.add(2, 3); // Act assertEquals(5, result); // Assert } } ``` - `@Test` marks `addsTwoNumbers` as a test. JUnit finds every `@Test` method and runs it. - `assertEquals(expected, actual)` is a **static assertion**: if the two values differ, it throws an `AssertionError` and JUnit records the test as *failed*; if they match, the test passes. The order is **expected first, actual second** — getting this backwards makes failure messages misleading. - Note there is no `public` and no `main`. In JUnit 5 test classes and methods can be package-private; the framework uses reflection to call them. ## The Arrange–Act–Assert (AAA) shape A clean unit test has three phases: **Arrange** (build the inputs and the object under test), **Act** (invoke the one behavior you're testing), **Assert** (verify the outcome). One test should check *one* logical behavior so that a failure points at exactly one cause. ## Lifecycle annotations (fixtures) A **fixture** is the fixed setup a test needs. JUnit gives you hooks so you don't copy setup into every test: | Annotation | When it runs | Typical use | |---|---|---| | `@BeforeEach` | before **every** `@Test` method | create fresh objects so tests don't share state | | `@AfterEach` | after **every** `@Test` method | clean up (close a file, clear a list) | | `@BeforeAll` | **once**, before all tests in the class | expensive one-time setup (start a DB/container) | | `@AfterAll` | **once**, after all tests in the class | tear that one-time thing down | ```java class OrderServiceTest { private OrderService service; @BeforeEach void setUp() { service = new OrderService(); } // fresh per test @Test void placesOrder() { /* uses a clean service */ } @Test void rejectsEmptyCart() { /* also a clean service */ } } ``` **Why per-test setup matters — test isolation.** JUnit, by default, creates a **brand-new instance of the test class for each test method**. Combined with `@BeforeEach`, this means each test starts from a known clean slate, so the *order* tests run in can't make one test pass or fail because of another. `@BeforeAll`/`@AfterAll` run once and therefore must be `static` (there's no single instance they belong to) — unless you annotate the class `@TestInstance(TestInstance.Lifecycle.PER_CLASS)`, which keeps one instance for the whole class and lets those methods be non-static (at the cost of weaker isolation). ## Other everyday annotations - `@DisplayName("adds two positive numbers")` — a human-readable name shown in reports. - `@Disabled("flaky until JIRA-123")` — skip a test without deleting it. - `@Nested` — an inner class to group related tests. - `assertThrows(IllegalArgumentException.class, () -> calc.divide(1, 0))` — assert that calling the lambda throws the given exception type; returns the exception so you can assert on its message. ## How this maps to the language-neutral discipline The *concepts* — what a unit test is, the testing pyramid, AAA, isolation — are universal. JUnit is just Java's **realization**: `@Test` is how you mark a unit test, `@BeforeEach` is how you build the fixture, and the `Assertions` class is how you express the verify step. Other languages have equivalents (pytest, NUnit, Jest); the ideas transfer, only the syntax changes.