Odkrivanje napak JavaScript z uporabo Rust in Headless Chrome

Obravnava napak JavaScript v Rust s Chromom Headless

Prepoznavanje težav z JavaScriptom je lahko bistveno za odpravljanje napak in zagotavljanje stabilnosti kode, ko se ukvarjate s spletno avtomatizacijo ali testiranjem. JavaScript je mogoče zagnati in spremeniti v brezglavem primerku brskalnika Chrome v Rust zahvaljujoč headless_chrome zaboj. Vendar pomanjkanje dokumentacije otežuje uporabo tega zaboja za odkrivanje težav z JavaScriptom.

V tem članku je razloženo, kako prepoznati težave z JavaScriptom z uporabo headless_chrome zaboj v Rustu, s poudarkom na upravljanju scenarijev, v katerih skript ne uspe. Posebej si bomo ogledali, kako uporabiti dogodke beleženja in odpravljanja napak v Chromu, da bomo pozorni na težave, kot so neuspele trditve.

Ena od težav, s katerimi se srečujejo razvijalci, je pravilna nastavitev poslušalcev dogodkov v Rustu za spremljanje določenih vrst napak JavaScripta. Kot bomo videli, bo morda potrebna nekaj nastavitev pred uporabo funkcij, kot je console.assert(false) za takojšnje ustvarjanje zaznavnih dogodkov; to zahteva globlje razumevanje Rustovih zmožnosti obravnavanja dogodkov.

Pregledali bomo vzorce kode, rešili pogoste težave in izboljšali poslušalce dogodkov, da bomo v prihajajočih delih učinkovito prestregli napake JavaScript. Ta postopek prikazuje, kako delo z zaboji, ki nimajo temeljite dokumentacije, zahteva poskuse in napake.

Kako odkriti napake JavaScript z Rust's Headless Chrome Crate

Namen skriptov je zagnati kodo JavaScript znotraj brezglavega brskalnika Chrome z uporabo zaboja Rust headless_chrome in prepoznati morebitne težave z JavaScriptom, ki se pojavijo. To je še posebej koristno pri uporabi spletnega strganja ali avtomatiziranega testiranja, da se prepričate, ali JavaScript deluje, kot je predvideno. Uporaba Brskalnik::novo, skript najprej inicializira nov primerek brskalnika in nekaj nastavi LaunchOptions, kot je velikost okna. Za zagotovitev, da brezglavi primerek Chroma deluje kot pravo okolje brskalnika, so te nastavitve posredovane.

Skript uporablja tab.new_tab() za ustvarjanje novega zavihka po inicializaciji brskalnika. Ta zavihek izvaja JavaScript na podoben način kot okno brskalnika. Z uporabo lahko poslušamo ključne dogodke, vključno z napakami JavaScript tab.enable_debugger() in tab.enable_log() da omogočite Chrome Debugger in funkcije beleženja. Natančneje, vklop teh zmožnosti omogoči skriptu uporabo Chromovega vgrajenega protokola za odpravljanje napak, ki je bistvenega pomena za lovljenje napak, ki morda niso očitne z običajnimi metodami beleženja.

Naprej, tab.add_event_listener() metodo uporablja skript za uporabo poslušalca dogodkov. Ta funkcija ustvari sistem za beleženje določenih dogodkov odpravljanja napak, kot je Razhroščevalnik zaustavljen, kar pomeni, da je bilo izvajanje prekinjeno zaradi težave z JavaScriptom ali prekinitvene točke. Poslušalec dogodkov ugotovi, ali je prišlo do napake JavaScript, tako da to zapre v zaprtje Rust. Program bo prestrašil in prikazal sporočilo o napaki, če bo odkrita napaka. S to metodo se napake JavaScripta ujamejo v realnem času, tudi če deluje brezglavo.

končno, tab.evaluate() se uporablja za ovrednotenje enostavnega stavka JavaScript, console.assert(false). Za simulacijo običajnega scenarija v spletnih aplikacijah, kjer bi bilo treba zajeti neuspešno trditev ali drugo težavo z JavaScriptom, ta ukaz namerno povzroči napako. Ko se pojavi težava, lahko razvijalci samodejno ustavijo izvajanje in sprožijo alarm s kombinacijo zaznavanja napak in razhroščevalnika. Nazadnje, skript počaka dovolj dolgo, da se JavaScript zažene in da se morebitne težave zabeležijo, preden se prekine, zahvaljujoč uporabi std::thread::sleep().

use headless_chrome::{protocol::cdp::types::Event, Browser, LaunchOptions};
use std::{error::Error, sync::Arc};
fn main() -> Result<(), Box<dyn Error>> {
    let browser = Browser::new(
        LaunchOptions::default_builder()
            .window_size(Some((2000, 2000)))
            .build()
            .expect("Could not find chrome-executable"),
    )?;
    let tab = browser.new_tab()?;
    tab.enable_debugger().unwrap();
    tab.enable_log().unwrap();
    let _events = tab.add_event_listener(Arc::new(move |event: &Event| {
        dbg!(event);
        if let Event::DebuggerPaused(_paused_event) = event {
            panic!("JavaScript error detected!");
        }
    }))?;
    let _remote_object = tab.evaluate("console.assert(false);", true).unwrap();
    std::thread::sleep(std::time::Duration::from_secs(1));
    Ok(())
}

use headless_chrome::{Browser, LaunchOptions};
use std::panic;
fn main() -> Result<(), Box<dyn std::error::Error>> {
    panic::set_hook(Box::new(|info| {
        println!("Panic occurred: {:?}", info);
    }));
    let browser = Browser::new(LaunchOptions::default())?;
    let tab = browser.new_tab()?;
    tab.enable_log()?;
    tab.evaluate("console.assert(false);", true)?;
    std::thread::sleep(std::time::Duration::from_secs(1));
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_js_error_detection() {
        let browser = Browser::new(LaunchOptions::default()).unwrap();
        let tab = browser.new_tab().unwrap();
        tab.enable_log().unwrap();
        let result = tab.evaluate("console.assert(false);", true);
        assert!(result.is_err(), "Expected JavaScript error!");
    }
}

Izboljšanje zaznavanja napak JavaScript v Rust z obravnavanjem dogodkov

Medtem ko se prvotni skript osredotoča na odkrivanje napak JavaScripta z uporabo headless_chrome paket, je bistvena tudi optimizacija učinkovitosti obravnave napak. Uporaba kompleksnejših vrst dogodkov, kot je npr Runtime.exceptionThrown je ena od metod za izboljšanje postopka. Natančnejše informacije o izjemah JavaScripta je mogoče pridobiti iz tega dogodka protokola, kar daje skrbnikom natančnejši nadzor nad tem, kako se obravnavajo te napake. Ta poslušalec dogodkov lahko zagotovi več informacij kot preprosta napaka trditve v situacijah, kjer pride do napak zaradi izjem med izvajanjem ali nepravilne kode.

Poleg tega, da ste pozorni na dogodke odpravljanja napak, je ključnega pomena elegantno obravnavati napake z Rustom. Na primer, Rust's Rezultat in Možnost tipe lahko razvijalci uporabljajo za ustvarjanje tipov napak po meri. To naredi vaše aplikacije Rust bolj robustne, saj omogoča izboljšano širjenje napak in obnovitev po okvarah JavaScript. Napake je mogoče hitreje prepoznati tako, da jih zabeležite v konzolo z nedvoumnimi sporočili, zlasti pri delu v brezglavem okolju brez vizualnih povratnih informacij iz brskalnika.

Poleg tega se lahko preizkusi izvajajo na različnih straneh ali kontekstih JavaScripta, ko headless_chrome se uporablja. Z nadzorom različnih zavihkov ali sej se lahko prepričate, da vaš JavaScript pravilno deluje v različnih spletnih aplikacijah. To lahko prihrani veliko časa pri odpravljanju napak v posameznih skriptih, saj vam omogoča sočasno testiranje več končnih točk glede težav z JavaScriptom v situacijah testiranja integracije.