rustenium 1.1.9

A modern, robust, high-performance WebDriver BiDi automation library for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use rustenium::browsers::{ChromeBrowser, BidiBrowser, cdp_browser::{CdpBrowser, FetchNodeOptions}};
use rustenium::nodes::AXNode;
use rustenium_cdp_definitions::browser_protocol::dom::types::NodeId;

pub async fn test_navigate_to_url(mut browser: ChromeBrowser) {
    let result = <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await;
    assert!(result.is_ok(), "navigate should succeed");
    browser.close().await.unwrap();
}

pub async fn test_navigate_returns_frame_or_loader(mut browser: ChromeBrowser) {
    let result = <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    assert!(
        result.frame_id.is_some() || result.loader_id.is_some(),
        "navigate result should contain frame or loader id"
    );
    browser.close().await.unwrap();
}

pub async fn test_navigate_multiple_pages(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://httpbin.org/html").await.unwrap();
    browser.close().await.unwrap();
}

pub async fn test_get_accessible_nodes_not_empty(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    let nodes = <ChromeBrowser as CdpBrowser>::get_accessible_nodes(&mut browser, false).await.unwrap();
    assert!(!nodes.is_empty(), "should have at least one accessibility node");
    browser.close().await.unwrap();
}

pub async fn test_get_accessible_nodes_squash_lte_full(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    let full = <ChromeBrowser as CdpBrowser>::get_accessible_nodes(&mut browser, false).await.unwrap();
    let squashed = <ChromeBrowser as CdpBrowser>::get_accessible_nodes(&mut browser, true).await.unwrap();

    fn count(nodes: &[AXNode]) -> usize {
        nodes.iter().map(|n| 1 + count(&n.children)).sum()
    }
    assert!(
        count(&squashed) <= count(&full),
        "squashed tree ({}) should have <= nodes than full tree ({})",
        count(&squashed),
        count(&full)
    );
    browser.close().await.unwrap();
}

pub async fn test_get_accessible_nodes_squash_no_blank_generic(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    let nodes = <ChromeBrowser as CdpBrowser>::get_accessible_nodes(&mut browser, true).await.unwrap();

    fn check(nodes: &[AXNode]) {
        for node in nodes {
            let name_blank = node.name_str().map_or(true, |s| s.trim().is_empty());
            let role_empty = node.role_str().map_or(true, |r| matches!(r, "none" | "generic" | "group"));
            assert!(
                !(name_blank && role_empty),
                "squashed tree should contain no blank generic nodes, found node_id: {}",
                node.node_id
            );
            check(&node.children);
        }
    }
    check(&nodes);
    browser.close().await.unwrap();
}

pub async fn test_fetch_node_by_node_id(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    let node = <ChromeBrowser as CdpBrowser>::fetch_node(
        &mut browser,
        FetchNodeOptions {
            node_id: Some(NodeId::new(1)),
            depth: Some(1),
            ..Default::default()
        },
    ).await.unwrap();
    assert!(node.node_type > 0, "fetched node should have a valid node type");
    browser.close().await.unwrap();
}

pub async fn test_fetch_node_with_depth_returns_children(mut browser: ChromeBrowser) {
    <ChromeBrowser as CdpBrowser>::navigate(&mut browser, "https://example.com").await.unwrap();
    let shallow = <ChromeBrowser as CdpBrowser>::fetch_node(
        &mut browser,
        FetchNodeOptions { node_id: Some(NodeId::new(1)), depth: Some(1), ..Default::default() },
    ).await.unwrap();
    let deep = <ChromeBrowser as CdpBrowser>::fetch_node(
        &mut browser,
        FetchNodeOptions { node_id: Some(NodeId::new(1)), depth: Some(5), ..Default::default() },
    ).await.unwrap();
    assert!(
        deep.children.len() >= shallow.children.len(),
        "deeper fetch should return at least as many children"
    );
    browser.close().await.unwrap();
}

pub async fn test_emulate_device_metrics(mut browser: ChromeBrowser) {
    let result = <ChromeBrowser as CdpBrowser>::emulate_device_metrics(&mut browser, 375, 812, 3.0, true).await;
    assert!(result.is_ok(), "emulate_device_metrics should succeed");
    browser.close().await.unwrap();
}

pub async fn test_create_tab(mut browser: ChromeBrowser) {
    let result = <ChromeBrowser as CdpBrowser>::create_tab(&mut browser, "https://example.com").await;
    assert!(result.is_ok(), "create_tab should succeed");
    browser.close().await.unwrap();
}