Testing

A unit test is a method marked @Test that checks one behavior using assertions like assertEquals. @BeforeEach/@AfterEach run setup/cleanup before and after every test; @BeforeAll/@AfterAll run once for the whole class.

Mockito creates fake versions of dependencies. when(x).thenReturn(y) sets up canned answers (stubbing — controlling input). verify(x).method() checks that your code actually called a dependency (verification — checking interactions). Stubs feed data in; mocks confirm behavior.

JUnit's assertEquals is fine for simple checks. AssertJ gives fluent, chainable assertions like assertThat(list).contains(x) with great readability and IDE autocomplete. Hamcrest uses matcher objects like assertThat(x, is(5)). AssertJ is the modern default.

TDD: write a failing test first (red), write just enough code to pass (green), then clean up the code (refactor), repeating in small loops. JUnit's @ParameterizedTest runs the same test logic over many input sets (via @ValueSource, @CsvSource, @MethodSource) instead of copy-pasting tests.

The pyramid says: many fast unit tests (plain JUnit + Mockito), fewer integration tests (@SpringBootTest, Testcontainers), and very few slow end-to-end tests. Flaky tests pass and fail without code changes, often due to timing, shared state, real time/randomness, or test ordering.

assertAll runs a group of assertions together and reports every failure at once. With plain asserts, the test stops at the first failure, so you only see one problem. assertAll shows all of them in one run.

The order is assertEquals(expected, actual). The first value is what you expect, the second is what your code produced. Swapping them still passes or fails correctly, but the failure message reads backwards and confuses you.

assertThrows runs a piece of code and checks it throws the exception type you expect. You pass the expected exception class and a lambda holding the code. The test passes only if that code throws that type (or a subtype).

An assertion checks the result you are testing: if it is false, the test FAILS. An assumption checks a precondition: if it is false, the test is SKIPPED (aborted), not failed. So a failed assumption is treated like a test that did not run.

@BeforeAll runs once before all the tests in a class; @AfterAll runs once after all of them. @BeforeEach and @AfterEach run before and after every single test method instead.

ArgumentCaptor catches the actual value passed to a mock's method so you can store it and check it afterward with normal assertions, instead of only checking that the method was called.

Argument matchers like any() or eq() tell Mockito how to match the arguments of a call instead of comparing exact values. Use any() when the value doesn't matter and eq(x) when you need a specific value but other arguments use matchers.

@Mock creates a fake stand-in for a dependency. @InjectMocks creates the real object you are testing and pushes those mocks into it, so you can test it in isolation without its real collaborators.

An unstubbed mock returns safe empty defaults: null for objects, 0 for numbers, false for booleans, and empty collections (an empty list/set/map, not null). So calling a method you didn't stub won't throw on its own.

A mock is a fake stand-in for a real object that you create with Mockito.mock(SomeClass.class). You use it to replace a real collaborator so your test exercises only the one class you care about, without its dependencies doing real work.

AssertJ is a Java assertion library. You write assertThat(actual) then chain readable checks like .isEqualTo(expected) or .isNotNull(). It reads left-to-right (actual first) and gives clear failure messages, unlike assertEquals(expected, actual) where the argument order is easy to mix up.

Hamcrest is a library of reusable 'matcher' objects. Instead of assertEquals(2, x), you write assertThat(x, is(2)). The matcher describes what you expect, reads almost like English, and prints a clear message when it fails.

Call assertThat on the collection, then chain: hasSize(n) for count, contains(a, b) to check elements are present, containsExactly(...) for the exact contents in order, containsExactlyInAnyOrder(...) ignoring order, and extracting("field") to assert on one property of each element.

Wrap the failing call in a lambda: assertThatThrownBy(() -> service.run()).isInstanceOf(IllegalArgumentException.class).hasMessageContaining("bad"). It runs the lambda, catches the thrown exception, and lets you assert on its type and message. assertThatExceptionOfType(X.class).isThrownBy(() -> ...) is an equivalent style.

equalTo checks equality, is wraps a matcher to read nicer, not inverts, nullValue checks for null, containsString checks a substring, and hasItem checks a collection contains an element. You combine them like assertThat(list, hasItem(equalTo(3))).

JaCoCo is a Java tool that measures how much of your code your tests actually run. While the tests execute, it watches the compiled code and records which lines and branches were hit, then produces a report.

JaCoCo counts coverage in several ways: how many lines ran, how many of the true/false paths of if/switch ran (branches), how many low-level instructions and methods ran, and code complexity. Line coverage can hide untested branches — a line can run yet only one side of its condition is checked.

Add the JaCoCo plugin to your build. It attaches an agent to the test run so coverage is recorded, then a report task turns that data into an HTML report. In Gradle you apply the jacoco plugin and run jacocoTestReport; in Maven you bind the prepare-agent and report goals.

JaCoCo has a verification step that fails the build if coverage falls below a number you set. In Gradle it's jacocoTestCoverageVerification; in Maven it's the check goal with rules. You can also exclude generated or boilerplate code (DTOs, generated sources) so it doesn't drag the number down.

Coverage shows which code ran during tests, not whether the tests check the right things. You can hit 100% with tests that assert nothing. So set realistic targets, focus on new/changed code, and pair coverage with techniques like mutation testing rather than chasing a single big percentage.