viewpoint-core 0.4.3

High-level browser automation API for Viewpoint
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213

#![cfg(feature = "integration")]

//! Tests for locator query operations using refs from ARIA snapshots.
//!
//! These tests verify query operations (text, attributes, checked state)
//! work correctly when using refs obtained via `page.locator_from_ref(ref)`.

mod common;

use viewpoint_core::{AriaSnapshot, Browser};

/// Test: query methods (is_checked, inner_text, get_attribute, input_value) via ref.
#[tokio::test]
async fn test_query_methods_via_ref() {
    common::init_tracing();

    let browser = Browser::launch()
        .headless(true)
        .launch()
        .await
        .expect("Failed to launch browser");

    let context = browser
        .new_context()
        .await
        .expect("Failed to create context");
    let page = context.new_page().await.expect("Failed to create page");

    page.set_content(
        r#"
        <html><body>
            <input type="checkbox" id="mycheck" checked />
            <p id="para" data-info="test-info">Hello World</p>
            <input type="text" id="myinput" value="initial value" />
        </body></html>
    "#,
    )
    .set()
    .await
    .expect("Failed to set content");

    // Capture snapshot with refs
    let snapshot = page.aria_snapshot().await.expect("Failed to get snapshot");

    // Test is_checked via ref (find checkbox)
    let checkbox_ref =
        common::find_ref_by_role(&snapshot, "checkbox", None).expect("Should find checkbox ref");
    let checkbox_locator = page.locator_from_ref(&checkbox_ref);
    let is_checked = checkbox_locator
        .is_checked()
        .await
        .expect("Failed to check is_checked via ref");
    assert!(is_checked, "Checkbox should be checked");

    // Test inner_text via ref (find paragraph)
    fn find_paragraph_ref(snapshot: &AriaSnapshot) -> Option<String> {
        if snapshot.role.as_deref() == Some("paragraph") {
            return snapshot.node_ref.clone();
        }
        for child in &snapshot.children {
            if let Some(r) = find_paragraph_ref(child) {
                return Some(r);
            }
        }
        None
    }
    let para_ref = find_paragraph_ref(&snapshot).expect("Should find paragraph ref");
    let para_locator = page.locator_from_ref(&para_ref);
    let inner_text = para_locator
        .inner_text()
        .await
        .expect("Failed to get inner_text via ref");
    assert_eq!(inner_text, "Hello World", "Should get correct inner text");

    // Test get_attribute via ref
    let attr = para_locator
        .get_attribute("data-info")
        .await
        .expect("Failed to get_attribute via ref");
    assert_eq!(
        attr.as_deref(),
        Some("test-info"),
        "Should get correct attribute"
    );

    // Test input_value via ref (find textbox)
    let input_ref =
        common::find_ref_by_role(&snapshot, "textbox", None).expect("Should find input ref");
    let input_locator = page.locator_from_ref(&input_ref);
    let value = input_locator
        .input_value()
        .await
        .expect("Failed to get input_value via ref");
    assert_eq!(value, "initial value", "Should get correct input value");

    browser.close().await.expect("Failed to close browser");
}

/// Test: aria_snapshot on locator via ref (nested snapshot).
#[tokio::test]
async fn test_aria_snapshot_on_locator_via_ref() {
    common::init_tracing();

    let browser = Browser::launch()
        .headless(true)
        .launch()
        .await
        .expect("Failed to launch browser");

    let context = browser
        .new_context()
        .await
        .expect("Failed to create context");
    let page = context.new_page().await.expect("Failed to create page");

    page.set_content(
        r#"
        <html><body>
            <div role="navigation">
                <button>Home</button>
                <button>About</button>
            </div>
        </body></html>
    "#,
    )
    .set()
    .await
    .expect("Failed to set content");

    // Capture snapshot with refs
    let snapshot = page.aria_snapshot().await.expect("Failed to get snapshot");

    // Find the navigation's ref
    let nav_ref = common::find_ref_by_role(&snapshot, "navigation", None)
        .expect("Should find navigation ref");

    // Get aria_snapshot of the navigation element via ref
    let locator = page.locator_from_ref(&nav_ref);
    let nested_snapshot = locator
        .aria_snapshot()
        .await
        .expect("Failed to get aria_snapshot via ref");

    let yaml = nested_snapshot.to_yaml();
    println!("Nested snapshot:\n{yaml}");

    // Verify it contains the buttons
    assert!(yaml.contains("Home"), "Should contain Home button");
    assert!(yaml.contains("About"), "Should contain About button");

    browser.close().await.expect("Failed to close browser");
}

/// Test: all_inner_texts and all_text_contents via ref.
#[tokio::test]
async fn test_all_texts_via_ref() {
    common::init_tracing();

    let browser = Browser::launch()
        .headless(true)
        .launch()
        .await
        .expect("Failed to launch browser");

    let context = browser
        .new_context()
        .await
        .expect("Failed to create context");
    let page = context.new_page().await.expect("Failed to create page");

    page.set_content(
        r#"
        <html><body>
            <ul>
                <li>Item 1</li>
                <li>Item 2</li>
                <li>Item 3</li>
            </ul>
        </body></html>
    "#,
    )
    .set()
    .await
    .expect("Failed to set content");

    // Capture snapshot with refs
    let snapshot = page.aria_snapshot().await.expect("Failed to get snapshot");

    // Find a list item ref
    let listitem_ref =
        common::find_ref_by_role(&snapshot, "listitem", None).expect("Should find listitem ref");

    // Test all_inner_texts via ref (single element returns array with one item)
    let locator = page.locator_from_ref(&listitem_ref);
    let inner_texts = locator
        .all_inner_texts()
        .await
        .expect("Failed to get all_inner_texts via ref");

    assert_eq!(inner_texts.len(), 1, "Should have 1 text (single element)");
    assert!(inner_texts[0].contains("Item"), "Should contain 'Item'");

    // Test all_text_contents via ref
    let text_contents = locator
        .all_text_contents()
        .await
        .expect("Failed to get all_text_contents via ref");

    assert_eq!(text_contents.len(), 1, "Should have 1 text content");
    assert!(text_contents[0].contains("Item"), "Should contain 'Item'");

    browser.close().await.expect("Failed to close browser");
}