Checkpoint Lab — JavaScript Execution, Browser Capabilities, Profiles, and Preferences

1. Checkpoint scenario and acceptance criteria

From an empty directory, build the same loopback fixture. Session A uses WebDriver-native text entry. Session B uses a narrowly scoped JavaScript helper to set the same value and dispatch one input event, but still uses WebDriver for the Apply business action. Both sessions configure the same isolated Chromium language preference and standard page-load strategy. A third session attempt deliberately requests one invalid capability and must fail before browser use.

2. Setup and preflight

The following example makes the Setup and preflight behavior concrete. Read it with the stated assumptions, then compare its observable output or state changes with the explanation that follows.

mkdir selenium-ch12-checkpoint
cd selenium-ch12-checkpoint
python -m venv .venv
# Windows PowerShell: .\.venv\Scripts\Activate.ps1
# Linux/macOS: source .venv/bin/activate
python -m pip install "selenium==4.47.0"
# Save Lesson 2's fixture generator as make_fixture.py
python make_fixture.py
python -m http.server 8777 --bind 127.0.0.1 --directory site

Preflight: Python 3.10+; Selenium 4.47.0; supported local Chromium-family browser; Selenium Manager allowed to resolve the driver; port 8777 free; no proxy credentials/personal profiles/production targets; filesystem permission for temporary profiles.

3. Write predictions before execution

1. Session A native typing will create more focus/key/input events than Session B's scripted value helper.
2. Both flows will end with the same visible saved:academy application state if the helper dispatches the required input event and Apply remains a native click.
3. Both valid sessions will report standard pageLoadStrategy=eager; the Chromium preference belongs under vendor options and its runtime effect is checked separately via navigator.language.
4. The invalid unprefixed capability session should fail during session creation and must not trigger any fallback such as JS bypass, insecure TLS, or browser restart loops.
5. Each valid session owns its own disposable profile, which is deleted only after quit().

4. Run the checkpoint

The following example makes the Run the checkpoint behavior concrete. Read it with the stated assumptions, then compare its observable output or state changes with the explanation that follows.

from pathlib import Path
import json
import shutil
import tempfile

import selenium
from selenium import webdriver
from selenium.common.exceptions import WebDriverException
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait

URL = "http://127.0.0.1:8777/"
root = Path(tempfile.mkdtemp(prefix="selenium-ch12-checkpoint-"))
evidence = root / "evidence"
evidence.mkdir()
packet = {"selenium": selenium.__version__, "runs": {}}


def new_options(profile: Path):
    options = webdriver.ChromeOptions()
    options.page_load_strategy = "eager"  # standard capability
    options.add_argument(f"--user-data-dir={profile.resolve()}")
    options.add_experimental_option("prefs", {"intl.accept_languages": "en-US"})
    return options


def run_flow(name: str, scripted: bool):
    profile = root / f"profile-{name}"
    profile.mkdir()
    options = new_options(profile)
    requested = options.to_capabilities()
    driver = webdriver.Chrome(options=options)
    try:
        driver.get(URL)
        WebDriverWait(driver, 2).until(lambda d: d.find_element(By.ID, "ready").text == "app:ready")
        field = driver.find_element(By.ID, "nickname")

        if scripted:
            # Deliberately narrow helper: state injection for comparison only.
            driver.execute_script("""
            arguments[0].value = arguments[1];
            arguments[0].dispatchEvent(new Event('input', {bubbles:true}));
            """, field, "academy")
        else:
            field.send_keys("academy")

        before_apply_events = int(driver.find_element(By.ID, "events").text.split(":")[1])
        driver.find_element(By.ID, "apply").click()  # always native business interaction
        WebDriverWait(driver, 2).until(
            lambda d: d.find_element(By.ID, "status").text == "saved:academy"
        )
        caps = driver.capabilities
        result = {
            "requested_standard": {"pageLoadStrategy": requested.get("pageLoadStrategy")},
            "requested_vendor": requested.get("goog:chromeOptions", {}),
            "returned": {
                "browserName": caps.get("browserName"),
                "browserVersion": caps.get("browserVersion"),
                "pageLoadStrategy": caps.get("pageLoadStrategy"),
            },
            "session_id": driver.session_id,
            "before_apply_events": before_apply_events,
            "language": driver.execute_script("return navigator.language"),
            "status": driver.find_element(By.ID, "status").text,
        }
        driver.save_screenshot(str(evidence / f"{name}.png"))
        return result
    finally:
        driver.quit()
        shutil.rmtree(profile)


packet["runs"]["native"] = run_flow("native", scripted=False)
packet["runs"]["script_helper"] = run_flow("script-helper", scripted=True)
assert packet["runs"]["native"]["status"] == "saved:academy"
assert packet["runs"]["script_helper"]["status"] == "saved:academy"
assert packet["runs"]["native"]["before_apply_events"] > packet["runs"]["script_helper"]["before_apply_events"]

# Reversible failure injection: an invalid, unprefixed capability.
bad = webdriver.ChromeOptions()
bad.set_capability("academyMadeUpCapability", True)
packet["invalid_capability_request"] = bad.to_capabilities()
try:
    bad_driver = webdriver.Chrome(options=bad)
except WebDriverException as exc:
    packet["invalid_capability_result"] = type(exc).__name__
else:
    bad_driver.quit()
    raise AssertionError("Expected the invalid capability to be rejected")

# Preserve only synthetic configuration/evidence metadata outside disposable profiles.
summary = Path("checkpoint-summary.json")
summary.write_text(json.dumps(packet, indent=2), encoding="utf-8")
shutil.rmtree(root)
assert not root.exists()
print("PASS", summary.resolve())

5. Compare observability and meaning

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

6. Portable versus browser-specific configuration record

The following table organizes the key choices and evidence for Portable versus browser-specific configuration record. Use it together with the surrounding prose so the rows serve as a comparison aid rather than standalone rules.

7. Evidence packet

• Selenium version and one session ID per valid flow.
• Requested standard capability subset and requested vendor options.
• Returned browser/version/page-load strategy.
• Native versus scripted event counts and final visible application status.
• Runtime language observation.
• First invalid-capability exception type and the exact synthetic capability request.
• Two screenshots from the synthetic fixture.
• No full personal profile, proxy credential, cookie token, or cloud secret capture.

8. Verification checklist

• Exactly two successful valid sessions, each with its own disposable profile.
• Native flow produces a richer input-event path than the scripted helper.
• Both valid flows reach the same visible business outcome through a native Apply click.
• Standard and Chromium-specific configuration are recorded separately.
• Runtime behavior is checked rather than assuming requested preferences were honored.
• Invalid capability fails at session negotiation; no retry/JS/TLS workaround is introduced.
• Profiles are deleted only after browser quit.
• Loopback fixture contains no real credentials/accounts/files.

9. Cleanup and rollback

The checkpoint deletes each profile immediately after its browser quits, then deletes the evidence root after writing the small synthetic summary. Stop the loopback server and remove the project directory when finished. No system browser profile/preferences or OS trust settings were changed.

10. What Chapter 12 adds to the production operating model

The browser-automation operating model now has explicit control-plane rules: WebDriver-first user behavior, bounded page-script helpers, standard versus vendor capability classification, per-session profile ownership, runtime verification of preferences, security review for trust/proxy settings, and configuration evidence for CI diagnosis.

Chapter 13 moves from browser configuration to maintainable test structure: Page Object, Page Component, Screenplay, and other abstraction patterns. The configuration boundaries learned here should remain outside page abstractions unless they are genuinely part of page behavior.

11. Summary

Browser-specific power is safe when its scope and lost semantics are explicit. A passing scripted shortcut is not automatically equivalent to user behavior, and a requested capability is not proof of runtime effect. Keep configuration minimal, isolated, observable, and reviewable.

Knowledge check

Official references and version notes

• Selenium 4.47 release notes — stable baseline pinned for this chapter.
• Selenium downloads — stable bindings/Grid versus 4.48 snapshot artifacts.
• Python WebDriver API — synchronous/asynchronous JavaScript execution and session capabilities.
• Browser options — standard capabilities including page-load strategy and insecure-certificate behavior.
• Chrome-specific functionality — Chromium option/configuration boundary.
• Python Chrome Options API — arguments, experimental options, capabilities, and to_capabilities().
• Python common Options API — page-load strategy and cross-browser option properties.
• Avoid sharing state — fresh-session isolation guidance.