Detekcia chýb JavaScript pomocou Rust a Headless Chrome

Spracovanie chýb JavaScriptu v Rust s Headless Chrome

Identifikácia problémov s JavaScriptom môže byť nevyhnutná pre ladenie a zaručenie stability kódu pri online automatizácii alebo testovaní. JavaScript môže byť spustený a upravený v inštancii prehliadača Chrome bez hlavy v Rust vďaka headless_chrome prepravka. Nedostatok dokumentácie však sťažuje použitie tejto prepravky na zisťovanie problémov s JavaScriptom.

Tento článok vysvetľuje, ako identifikovať problémy s JavaScriptom pomocou headless_chrome crate in Rust, s dôrazom na manažovanie scenárov, v ktorých scenár zlyhá. Konkrétne sa pozrieme na to, ako používať udalosti protokolovania a ladenia v prehliadači Chrome, aby sme dávali pozor na problémy, ako sú napríklad neúspešné tvrdenia.

Správne nastavenie poslucháčov udalostí v Ruste na monitorovanie konkrétnych druhov zlyhaní JavaScriptu je jedným z problémov, s ktorými sa vývojári stretávajú. Ako uvidíme, pred použitím funkcií ako napr console.assert(false) okamžite generovať zistiteľné udalosti; to si vyžaduje hlbšie pochopenie schopností Rustu zvládať udalosti.

Prejdeme si ukážky kódu, vyriešime bežné problémy a vylepšíme poslucháčov udalostí, aby sme v nadchádzajúcich častiach efektívne zachytávali chyby JavaScriptu. Tento postup ukazuje, ako si práca s prepravkami, ktoré nemajú dôkladnú dokumentáciu, vyžaduje pokusy a omyly.

Ako zistiť chyby JavaScriptu s hrdzou Chrome Crate

Účelom skriptov je spustiť kód JavaScript v bezhlavom prehliadači Chrome pomocou prepravky Rust headless_chrome a identifikujte prípadné problémy s JavaScriptom. Toto je obzvlášť užitočné pri používaní webového zoškrabovania alebo automatizovaného testovania, aby ste sa uistili, že JavaScript funguje podľa plánu. Používanie Prehliadač::nový, skript najprv inicializuje novú inštanciu prehliadača a niektoré nastaví Možnosti spustenia, ako je veľkosť okna. Tieto nastavenia sa odovzdajú, aby sa zabezpečilo, že bezhlavá inštancia prehliadača Chrome funguje ako skutočné prostredie prehliadača.

Skript používa tab.new_tab() na vygenerovanie novej karty po inicializácii prehliadača. Táto karta spúšťa JavaScript podobným spôsobom ako okno prehliadača. Používaním môžeme počúvať dôležité udalosti vrátane chýb JavaScriptu tab.enable_debugger() a tab.enable_log() aktivovať funkcie Chrome Debugger a zapisovanie do denníka. Zapnutie týchto funkcií konkrétne umožňuje skriptu používať vstavaný protokol ladenia prehliadača Chrome, ktorý je nevyhnutný na zachytenie chýb, ktoré sa nemusia prejaviť bežnými metódami protokolovania.

Ďalej, tab.add_event_listener() metódu používa skript na použitie poslucháča udalostí. Táto funkcia vytvára systém na zaznamenávanie konkrétnych udalostí ladenia, napr DebuggerPaused, čo znamená, že vykonávanie bolo prerušené z dôvodu problému s JavaScriptom alebo bodu prerušenia. Poslucháč udalostí určí, či došlo k chybe JavaScriptu, a to tak, že to uzavrie do uzáveru Rust. Softvér spanikári a ak sa nájde chyba, zobrazí sa chybové hlásenie. Pri tejto metóde sa chyby JavaScriptu zachytávajú v reálnom čase aj pri bezhlavej práci.

nakoniec tab.evaluate() sa používa na vyhodnotenie jednoduchého príkazu JavaScript, console.assert(false). Aby bolo možné simulovať bežný scenár vo webových aplikáciách, kde by bolo potrebné zachytiť neúspešné tvrdenie alebo iný problém s JavaScriptom, tento príkaz zámerne spôsobí chybu. Keď sa vyskytne problém, vývojári môžu automaticky pozastaviť vykonávanie a spustiť alarm kombináciou detekcie chýb a ladiaceho nástroja. Nakoniec skript čaká dostatočne dlho na spustenie JavaScriptu a na zaznamenanie akýchkoľvek problémov pred ukončením vďaka použitiu 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!");
    }
}

Vylepšenie detekcie chýb JavaScriptu v hrdze pomocou obsluhy udalostí

Zatiaľ čo pôvodný skript sa sústreďuje na detekciu chýb JavaScriptu pomocou headless_chrome optimalizácia efektívnosti odstraňovania chýb je tiež nevyhnutná. Pomocou zložitejších typov udalostí ako napr Runtime.exceptionThrown je jednou z metód na zlepšenie procesu. Konkrétnejšie informácie o výnimkách JavaScriptu je možné získať z tejto udalosti protokolu, čo správcom poskytuje presnejšiu kontrolu nad tým, ako sa s týmito zlyhaniami zaobchádza. Tento poslucháč udalostí môže poskytnúť viac informácií ako len zlyhanie jednoduchého tvrdenia v situáciách, keď sa vyskytnú chyby z dôvodu výnimiek za behu alebo nesprávneho kódu.

Okrem toho, že musíte dávať pozor na udalosti ladenia, je dôležité elegantne zvládnuť chyby s Rustom. Napríklad Rust's Výsledok a Možnosť typy môžu vývojári použiť na vytvorenie typov chýb na mieru. Vďaka tomu sú vaše aplikácie Rust robustnejšie, pretože umožňuje lepšie šírenie chýb a obnovu po zlyhaniach JavaScriptu. Chyby sa dajú rýchlejšie identifikovať ich prihlásením do konzoly s jednoznačnými správami, najmä pri práci v bezhlavom prostredí bez vizuálnej spätnej väzby z prehliadača.

Okrem toho je možné testy spustiť na rôznych stránkach alebo v kontextoch JavaScriptu headless_chrome sa používa. Môžete sa uistiť, že váš JavaScript funguje správne v rôznych online aplikáciách ovládaním rôznych kariet alebo relácií. To môže ušetriť veľa času pri ladení jednotlivých skriptov tým, že vám umožní testovať niekoľko koncových bodov súčasne na problémy s JavaScriptom v situáciách testovania integrácie.