Writing Tests with the sb Fixture

cargo test is the one test runner, and rstest supplies the fixtures. A test asks for sb: Sb (WebDriver, a BaseCase) or sb_cdp: SbCdp (pure CDP, a Page) and hands its body to run. The library then does what Python’s sb fixture does with the pytest options: it reads the run configuration, reruns a failed test, stops one that runs too long, leaves the evidence of a failure in latest_logs/, and closes the browser whatever happened.

Set up#

[dev-dependencies]seleniumbase-rs = { git = "https://github.com/MustCodeAl/seleniumbase-rs", features = ["testing"] }rstest = "0.26"tokio = { version = "1", features = ["macros", "rt"] }

A test#

use rstest::rstest;use seleniumbase_rs::testing::{sb, Sb};use seleniumbase_rs::Result;#[rstest]#[tokio::test]async fn valid_login(sb: Sb) -> Result<()> {    sb.run(async |sb| {        sb.open("https://example.com/login").await?;        sb.type_text("#user", sb.account().unwrap_or("demo")).await?;        sb.assert_title("Example Domain").await    })    .await}

sb.run launches the browser, calls the closure with the open BaseCase, and closes the browser. It returns the test’s error, so ? and the assertions of BaseCase fail the test as usual; an assert! that panics fails it too, after the browser is closed. The closure is called again on a rerun, so it must not move out of what it captures.

For the pure CDP engine ask for sb_cdp: SbCdp and write sb_cdp.run(async |page| { ... }); the body gets the first Page. A Page has no test data of its own, so read it with sb_cdp.data().

Use #[case] for several inputs; each case is its own test with its own id and its own folder of evidence:

#[rstest]#[case("qa", "https://qa.example.com")]#[case("staging", "https://staging.example.com")]#[tokio::test]async fn home_page(sb: Sb, #[case] name: &str, #[case] url: &str) -> Result<()> {    sb.run(async |sb| {        sb.open(url).await?;        sb.assert_element("h1").await    })    .await}

What the run configuration does#

The fixture reads Settings::load: the settings file (sbase_config.toml, or the file SB_SETTINGS_FILE names), with the SB_* variables on top. The test-related keys live in the [test] table and have a variable each.

The browser settings (headless, browser, proxy, dark_mode, …) apply as they do everywhere else; see the settings page. To change one setting for one test, the Rust form of Python’s SB(...) arguments, use configure:

#[rstest]#[tokio::test]async fn flaky_page(sb: Sb) -> Result<()> {    let sb = sb.configure(|settings| {        settings.test.reruns = 2;        settings.test.time_limit = Some(60.0);    });    sb.run(async |sb| sb.open("https://example.com").await).await}

Test data#

--env, --account, --data, --var1 to --var3 and --variables of Python SeleniumBase are read from the BaseCase under the same names: sb.env() (test when none was given, otherwise one of the 24 environments, in lower case), sb.environment(), sb.account(), sb.data(), sb.var1(), sb.var2(), sb.var3() and sb.variables(), a JSON map. SB_VARIABLES takes a JSON object or the Python dictionary literal Python accepts.

Evidence of a failure#

A failed attempt leaves a folder named after the test, taken while the browser is still open:

latest_logs/cart.checkout.renders/  screenshot.png          (not with no_screenshot)  page_source.html  basic_test_info.txt     test id, last page, duration, browser, time, error

The test id is the test binary, the module path and the function, joined with .; an rstest case adds its name. It is also sb.test_id(). The folder is written again by each attempt, so after a rerun it holds the last failure.

Debug prompts#

trace stops before the body, pdb after a failed last attempt (a post-mortem, the browser still open), and final_debug after every test, before the browser closes. Each prompt reads c to continue, s for a screenshot, src for the page source, u for the address, js <expression> and q to quit. Python’s stepping commands (n, s, r) have no equivalent.

Seeing how every attempt ended#

Implement seleniumbase_rs::testing::Finalizer and register it with sb.finalizer(Arc::new(MyFinalizer)) to be told, once per attempt and with the page still open, how the attempt ended (Outcome::Passed, Failed or Skipped), how long it took and which attempt it was. The dashboard, the results database and the recorder plug in this way.