Framework Integration: pytest, JUnit, TestNG, NUnit, and Language Bindings: Core Concepts and Mental Model

1. The practical problem: two libraries, three lifecycles, one browser contract

Selenium test code often looks like one program, but it is actually a collaboration between at least three layers. The language binding sends WebDriver commands. The test framework discovers tests, creates fixtures, evaluates assertions, parameterizes cases, schedules concurrency, and reports outcomes. The browser/Grid/AUT hold execution state outside both libraries.

Confusing those layers produces brittle suites: a runner-level retry is mistaken for a WebDriver wait, a class-scoped driver is shared because the framework permits it, or a JavaScript Promise is treated like Python return value. This chapter keeps the observable browser behavior constant while changing framework mechanics around it.

2. Mental model: framework orchestration wraps WebDriver; it does not replace it

The following diagram visualizes the relationships described in Mental model: framework orchestration wraps WebDriver; it does not replace it. Read the nodes in sequence and use the arrows to connect the conceptual state changes to the explanation around the diagram.

flowchart TD
  C[Canonical behavior spec] -- discovered by --> F[Test framework]
  F -- fixture/hook --> B[Official Selenium language binding]
  B -- WebDriver commands --> X[Local driver or Grid]
  X -- owns --> R[Browser session]
  R -- exercises --> A[Disposable AUT]
  F -- assertion/report --> E[Result + evidence]
  R -- capabilities/session id --> E

The behavior specification states what the user should observe. Framework discovery chooses which test function/method runs. A fixture or hook creates the binding’s WebDriver object. The binding talks to a local driver or Grid, which owns the browser session. Assertions live in the test/framework layer; browser capabilities and session identifiers remain WebDriver evidence.

3. Define the objects before changing lifecycle

The following table organizes the key choices and evidence for Define the objects before changing lifecycle. Use it together with the surrounding prose so the rows serve as a comparison aid rather than standalone rules.

Credentials are not “framework data.” They are security-sensitive inputs that should enter through approved secret/config channels and be scoped to synthetic test identities. Reports and screenshots can persist beyond the browser session, so their privacy boundary is different from in-memory test state.

4. Current framework and binding landscape

The following table organizes the key choices and evidence for Current framework and binding landscape. Use it together with the surrounding prose so the rows serve as a comparison aid rather than standalone rules.

Framework versions are deliberately recorded because they evolve independently from Selenium. The browser protocol is shared, but lifecycle APIs, assertion syntax, async behavior, parameterization, reporting, and plugin features are not guaranteed to match.

5. Read-only proof before framework mutation

The following example makes the Read-only proof before framework mutation behavior concrete. Read it with the stated assumptions, then compare its observable output or state changes with the explanation that follows.

from importlib.metadata import version
from selenium import webdriver

print("selenium:", version("selenium"))
driver = webdriver.Chrome()  # Selenium Manager resolves a compatible driver by default.
try:
    caps = driver.capabilities
    print("session_id:", driver.session_id)
    print("browser:", caps.get("browserName"), caps.get("browserVersion"))
    print("platform:", caps.get("platformName"))
    print("driver evidence:", caps.get("chrome", {}).get("chromedriverVersion"))
    print("url/title before navigation:", driver.current_url, driver.title)
finally:
    driver.quit()

This first program avoids framework fixtures entirely. It proves the installed Selenium version, session ID, returned browser/platform capabilities, driver evidence where Chrome exposes it, and current URL/title. When a later pytest hook fails, these values let you ask whether the problem appeared before or after framework integration.

6. Discovery and lifecycle are framework semantics

A framework decides which test is visible and when setup/teardown runs. In pytest, fixture scope can be function, class, module, package, or session. JUnit Jupiter uses lifecycle annotations and configurable test-instance behavior. TestNG has its own annotation hierarchy. NUnit has setup/teardown attributes. Mocha uses hooks around suites/tests.

7. Assertions are not WebDriver commands

driver.find_element(...) asks the browser for an element. assert actual == expected, JUnit assertEquals, NUnit Assert.That, and Node assert.equal evaluate test meaning in the runner process. A missing element may raise a Selenium exception before an assertion runs; a mismatched string normally raises the framework/assertion library’s failure type.

8. Parameterization changes inputs, not browser semantics

pytest @pytest.mark.parametrize, JUnit @ParameterizedTest, TestNG @DataProvider, NUnit [TestCase], and loop-generated Mocha cases can all express “run the same behavior against several inputs.” The exact syntax differs, but each invocation still needs a deterministic data identity, an explicit session-lifecycle decision, and evidence that identifies the parameter.

9. Parallelism is a scheduler decision constrained by session ownership

Framework-level parallel execution can create more runnable tests than Grid has slots or the AUT can safely isolate. Chapters 19–21 already established that runner workers and Grid capacity are separate controls. A framework plugin such as pytest-xdist or TestNG/JUnit parallel configuration must never cause multiple workers to share one mutable WebDriver object.

10. Sync and async bindings express the same remote operations differently

Python, Java, and typical .NET Selenium calls appear synchronous: the call returns after the WebDriver command completes or fails. JavaScript Selenium returns Promises and therefore requires await (or explicit Promise chaining) for commands whose result or completion matters. Forgetting await is a test-code bug even if the browser eventually performs the command.

11. Security, privacy, evidence, and trust boundaries

• Framework configuration may read environment variables, but secret values must not be printed in parameter IDs or reports.
• Per-test profiles/download directories prevent cross-test data leakage.
• Remote Grid endpoints remain private/authorized infrastructure.
• Assertions should compare redacted/non-sensitive data where possible.
• Teardown must run after failure and preserve first-failure evidence before destructive cleanup.

12. DevOps operating model: choose frameworks for ownership, not novelty

A useful framework makes discovery, ownership, reports, fixtures, and CI integration predictable for the team. It should not force every service into one language, nor should a polyglot organization allow browser semantics to drift. Keep a small canonical behavior vocabulary—navigation, stable locators, explicit waits, business assertions, evidence, cleanup—and let each service express that contract idiomatically.

Official references and current-version notes

• Selenium downloads — Stable 4.47.0 for Java, Python, .NET, JavaScript, Ruby, and Grid as of August 10, 2026.
• Organizing and Executing Selenium Code — Official examples list JUnit, TestNG, pytest/unittest, NUnit/MSTest, RSpec/Minitest, and Jest/Mocha test runners.
• Install a Selenium library — Current Selenium examples pin selenium==4.47.0, pytest==9.1.1, and JUnit BOM 6.1.3.
• pytest changelog — pytest 9.1.1 release baseline.
• JUnit 6.1.3 User Guide — JUnit 6.1.3; Java 17+ runtime requirement.
• TestNG documentation — Current documentation reports TestNG 7.9.0.
• NUnit framework release notes — NUnit 4.6.1 release baseline.
• selenium-webdriver npm package — JavaScript binding 4.47.0 and Node.js 22+ runtime floor.
• Mocha package — Mocha 11.8.0 stable baseline used by the comparison.

Knowledge checks

Summary and next bridge

This lesson keeps test-framework mechanics subordinate to the WebDriver/browser contract: lifecycle, assertions, parameters, async behavior, scheduling, and reports remain explicit rather than hiding session ownership or failure meaning.

Next: Framework Integration: pytest, JUnit, TestNG, NUnit, and Language Bindings: Guided Hands-On Workflow