Glossary

Application Programming Interface — URLs a backend exposes that accept requests and return data (usually JSON). Testing the API skips the browser entirely.

A file a CI run saves for download afterwards — in this course, failure screenshots and surefire reports.

The line of code that compares expected vs actual and declares pass or fail. The Expected Result column of a manual test case, as code — and this course's namesake.

A parent class your test classes extend to inherit shared setup and teardown (fresh browser in, guaranteed quit out).

Test design technique: probe the edges (0, 1, 99, 100) where bugs cluster. A manual-tester skill that transfers to automation unchanged.

A parallel line of work in a repository. Develop tests on a branch; merge when green.

Continuous Integration / Delivery — a server runs your suite automatically on every push (and on a schedule), so nobody has to remember.

A labeled snapshot in Git history. Write messages like defect summaries.

A pattern that matches elements: #id, .class, [attr='value'], and hierarchy via spaces and >. Your default locator dialect.

One test method fed many data rows (@ParameterizedTest + @CsvSource) — each row reported as its own test.

A library your project uses, declared in pom.xml; Maven downloads it automatically.

The browser's built-in inspector (F12): the Elements panel shows the DOM, the Console evaluates $$() and $x().

Document Object Model — the live tree the browser builds from HTML. Automation talks to this tree, not to pixels.

Hiding the messy details behind clean methods. The principle that makes the Page Object Model work: pages hide locators, tests never see them.

One URL of an API, e.g. /users/1. Verbs (GET, POST…) define what happens to it.

WebDriverWait + ExpectedConditions: poll a specific condition and proceed the moment it's true. The flakiness cure — and the only wait style this course uses.

Unscripted investigation guided by human judgment. Stays manual forever; scripts only check what you told them to check.

Setup/teardown code around tests: @BeforeEach / @AfterEach per test, @BeforeAll / @AfterAll per class.

A test that passes and fails without code changes — usually a timing race. Flakiness is what makes teams stop trusting suites.

The agreed structure around tests: pages/, tests/, utils/, config, reporting, CI. Mostly organization, not magic.

Running the browser without a window (--headless=new). Required in CI, faster everywhere; always set an explicit window size.

An element attribute meant to be unique on the page. The gold-standard locator when present.

A global find-element timeout. Mixing it with explicit waits causes unpredictable delays — this course avoids it entirely.

A class reusing another's members (LoginTest extends BaseTest). How frameworks share setup.

A contract of methods with no implementation. WebDriver is one — which is why the same test drives Chrome or Firefox.

Java Development Kit: the compiler and runtime. This course pins Eclipse Temurin 21.

The data format APIs speak: {"key": value} pairs, nested objects, arrays. Paths like address.city target values inside it.

Java's standard test framework: @Test methods, lifecycle annotations, assertions, and the runner Maven invokes.

The address of an element: an id, CSS selector, or XPath. Good ones are unique, stable, readable.

Java's build tool: downloads dependencies, compiles, runs tests. mvn test is the command CI runs.

One class per page owning its locators and actions; tests hold assertions and zero locators. A UI change becomes a one-file fix.

Running test classes concurrently (junit-platform.properties). Safe only when tests are independent.

See data-driven testing — the JUnit 5 annotation that powers it.

Environment variables telling Windows where programs live. The source of most setup problems — and always fixed by reopening the terminal after changing them.

Maven's project file: dependencies, versions, plugins. Declaration order matters for REST Assured.

Push uploads your commits to the shared repo; pull downloads teammates'.

Re-checking that existing behavior still works after changes. The highest-ROI automation target.

The dominant API style: verbs (GET, POST, PUT, PATCH, DELETE) acting on endpoint URLs, answering with status codes and JSON.

The fast critical-path subset (@Tag("smoke")) run on every push; the full suite runs nightly.

A WebElement reference whose node was re-rendered away. Re-find after the DOM changes.

The API's verdict: 200 OK, 201 Created, 4xx your request was wrong, 5xx the server broke.

The Maven plugin that discovers and runs tests, prints the Tests run summary, and writes reports CI parses.

A label on tests enabling subsets: mvn test -Dgroups=smoke.

Many unit tests, some API tests, few UI tests — because UI tests are the slowest and most fragile layer.

A JUnit extension that reacts to results — this course uses it to save a screenshot at the moment of failure.

Selenium's core interface: the object whose methods drive a real browser (get, findElement, quit).

The other locator dialect. Adds what CSS can't do: matching by visible text and walking up to ancestors.