Best practices

Prefer an id or a test attribute (#checkout, [data-testid="total"]) over a long CSS path or a position (div > div:nth-child(3)). Use link text (link=Sign in) for links whose text is the contract. See Selectors.

sb.click("#checkout").await?;sb.assert_text_visible("$42.00", "[data-testid=\"total\"]").await?;

sb.click("div.main > div:nth-child(3) > button").await?;sb.assert_text_visible("$42.00", "body > div > span.price-2").await?;

Actions and assertions wait for their element, so a fixed sleep only makes a test slower, or flaky when the page is slower than the sleep. When you need to wait for something an action does not cover, use a wait method with a timeout (wait_for_element_visible(selector, timeout_secs)). See Waits and assertions.

sb.click("#save").await?;sb.wait_for_element_visible("#saved-toast", 10).await?; // up to 10 s, no longer than needed

sb.click("#save").await?;sb.sleep(3.0).await; // too long when fast, too short when slow

Check visible text and elements (assert_text_visible("Welcome!", "body")) rather than internals. Note the order: the expected text comes first, then the selector.

Every call returns a Result. ? stops the test at the first failure with an error that names the selector; ignoring the result hides failures. See Taking advantage of Rust.

A test that fails before sb.quit() leaves a Chrome running. sb_test! and run_browser_test always quit, even on failure. See Macros.

A helper written for BrowserApi and ElementApi runs on both engines, so you can switch a suite from WebDriver to pure CDP without rewriting it. See Capability traits.

A test that checks one thing fails for one reason, so its name says what broke. Keep tests independent: each signs in or loads a saved session itself, rather than relying on a test that ran before it.

When several tests touch the same page, keep its selectors and steps in a small struct (a page object), so a changed selector is fixed once:

use seleniumbase_rs::BaseCase;pub struct LoginPage<'a> {    sb: &'a mut BaseCase,}impl<'a> LoginPage<'a> {    pub fn new(sb: &'a mut BaseCase) -> Self {        Self { sb }    }    pub async fn sign_in(&mut self, user: &str, password: &str) -> seleniumbase_rs::Result<()> {        self.sb.open("https://seleniumbase.io/simple/login").await?;        self.sb.type_text("#username", user).await?;        self.sb.type_text("#password", password).await?;        self.sb.click("#log-in").await    }}

When a page has many independent things to check, deferred assertions record each failure and report them all at the end, instead of stopping at the first:

sb.deferred_assert_element("#header").await?;sb.deferred_assert_text("Total", "#summary").await?;sb.deferred_assert_element("#footer").await?;sb.process_deferred_asserts().await?; // fails here, listing every miss

There is no screen there. Set SB_HEADLESS=true for sbrs and code that loads Settings; BrowserConfig::default() is already headless. Debug headed on your own machine. See Headless and headed browsers.

chromedriver must have the same major version as Chrome. sbrs doctor shows both; sbrs install fetches the matching driver. Or use the pure CDP engine, which needs no driver. See WebDriver and drivers.

Starting Chrome is the slowest step. Share browsers between tests with --reuse-session, or hand out pages from a BrowserPool in the pure CDP engine. See Pure CDP.

Save a screenshot and the page source when a test fails (save_screenshot, save_page_source_to_logs), and turn on logs with SB_LOG_LEVEL=debug when you investigate. See Tracing and logging.

Read passwords and TOTP secrets from environment variables, and never commit saved cookie files: anyone with them is signed in as you. See Sessions, cookies and storage and MFA and TOTP.

Space out requests and retry with backoff instead of hammering a page; the crate has RetryPolicy and RateLimiter for this. Respect a site’s terms of use.

If you change the browser’s identity, change it as a whole: a Fingerprint draws random values together (operating system, region, locale), and .seed(..) makes a run repeatable. A proxy in one country with a time zone in another is a giveaway. See Detection and spoofing.