„JavaScript“ klaidų aptikimas naudojant „rūdį“ ir „Chrome“ be galvos

„JavaScript“ klaidų tvarkymas rūdyje naudojant „Chrome“ be galvos

„JavaScript“ problemų nustatymas gali būti labai svarbus derinant ir garantuojant kodo stabilumą automatizuojant ar testuojant internetu. „JavaScript“ gali būti paleista ir modifikuota „Chrome“ naršyklėje be galvos, „Rust“ dėka begalvis_chromas dėžė. Tačiau dėl dokumentų trūkumo sunku naudoti šią dėžę „JavaScript“ problemoms aptikti.

Šiame straipsnyje paaiškinama, kaip nustatyti „JavaScript“ problemas naudojant begalvis_chromas Crate in Rust, pabrėžiant scenarijų, kai scenarijus nepavyksta, valdymą. Konkrečiai apžvelgsime, kaip naudoti žurnalų registravimo ir derinimo įvykius naršyklėje „Chrome“, kad būtų išvengta problemų, pvz., nepavykusių tvirtinimų.

Vienas iš sunkumų, su kuriais susiduria kūrėjai, yra tinkamas įvykių klausytojų nustatymas „Rust“, kad būtų galima stebėti, ar nėra tam tikrų „JavaScript“ klaidų. Kaip matysime, gali prireikti tam tikros sąrankos prieš naudojant tokias funkcijas kaip console.assert(false) nedelsiant generuoti aptinkamus įvykius; tam reikia giliau suprasti Rust įvykių valdymo galimybes.

Peržiūrėsime kodo pavyzdžius, išspręsime įprastas problemas ir patobulinsime įvykių klausytojus, kad būsimose dalyse efektyviai užfiksuotų JavaScript klaidas. Ši procedūra parodo, kaip dirbant su dėžėmis, kuriose nėra išsamių dokumentų, reikia bandymų ir klaidų.

Kaip aptikti „JavaScript“ klaidas naudojant „Rust's Chrome“ dėžę be galvos

Scenarijų tikslas yra paleisti „JavaScript“ kodą „Chrome“ naršyklėje be galvos, naudojant „Rust“ dėžę begalvis_chromas ir nustatyti bet kokias „JavaScript“ problemas. Tai ypač naudinga naudojant žiniatinklio duomenų rinkimą arba automatinį testavimą siekiant įsitikinti, kad „JavaScript“ veikia taip, kaip numatyta. Naudojant Naršyklė::nauja, scenarijus pirmiausia inicijuoja naują naršyklės egzempliorių ir nustato kai kuriuos LaunchOptions, pvz., lango dydis. Siekiant užtikrinti, kad „Chrome“ egzempliorius be galvos veiktų kaip tikroji naršyklės aplinka, šie nustatymai perduodami.

Scenarijus naudoja tab.new_tab() Norėdami sugeneruoti naują skirtuką po naršyklės inicijavimo. Šiame skirtuke „JavaScript“ veikia panašiai kaip naršyklės lange. Naudodami galime klausytis esminių įvykių, įskaitant „JavaScript“ klaidas tab.enable_debugger() ir tab.enable_log() kad įgalintumėte „Chrome“ derinimo ir registravimo funkcijas. Konkrečiai, įjungus šias galimybes, scenarijus gali naudoti įtaisytąjį „Chrome“ derinimo protokolą, kuris yra būtinas norint užfiksuoti gedimus, kurie gali būti nepastebimi naudojant įprastus registravimo metodus.

Toliau, tab.add_event_listener() metodą scenarijus naudoja įvykių klausytojui įdarbinti. Ši funkcija sukuria sistemą tam tikriems derinimo įvykiams įrašyti, pvz DebuggerPristabdytas, kuris rodo, kad vykdymas buvo nutrauktas dėl JavaScript problemos arba lūžio taško. Įvykių klausytojas nustato, ar buvo „JavaScript“ klaida, įtraukdama ją į „Rust“ uždarymą. Programinė įranga panikuoja ir parodys klaidos pranešimą, jei bus rasta klaida. Naudojant šį metodą, net veikiant be galvos, JavaScript klaidos užfiksuojamos realiuoju laiku.

Galiausiai, tab.evaluate() naudojamas norint įvertinti paprastą „JavaScript“ teiginį, console.assert(false). Siekiant imituoti įprastą scenarijų žiniatinklio programose, kai reikia užfiksuoti nepavykusį tvirtinimą ar kitą „JavaScript“ problemą, ši komanda tikslingai sukelia klaidą. Iškilus problemai, kūrėjai gali automatiškai pristabdyti vykdymą ir suaktyvinti aliarmą, derindami klaidų aptikimą ir derinimo priemonę. Galiausiai, scenarijus laukia pakankamai ilgai, kol bus paleistas JavaScript ir bus įrašytos visos problemos, prieš baigiant, nes naudojamas 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!");
    }
}

„JavaScript“ klaidų aptikimo rūdyje pagerinimas naudojant įvykių tvarkymą

Nors originalus scenarijus sutelktas į „JavaScript“ klaidų aptikimą naudojant begalvis_chromas Taip pat labai svarbu optimizuoti klaidų valdymo efektyvumą. Naudojant sudėtingesnius įvykių tipus, pvz Runtime.exceptionThrown yra vienas iš būdų pagerinti procesą. Iš šio protokolo įvykio galima gauti tikslesnės informacijos apie „JavaScript“ išimtis, todėl administratoriai gali tiksliau valdyti, kaip šios gedimai tvarkomi. Ši įvykių klausytoja gali pateikti daugiau informacijos nei paprastas tvirtinimo gedimas situacijose, kai dėl vykdymo laiko išimčių arba neteisingo kodo atsiranda klaidų.

Labai svarbu grakščiai tvarkyti klaidas naudojant Rust, be to, neužmiršti įvykių derinimo. Pavyzdžiui, Rust's Rezultatas ir Variantas tipus kūrėjai gali naudoti kurdami pagal užsakymą pritaikytus klaidų tipus. Dėl to jūsų „Rust“ programos tampa patikimesnės, nes įgalina geresnį klaidų plitimą ir atkūrimą po „JavaScript“ gedimų. Klaidas galima greičiau atpažinti užregistravus jas konsolėje vienareikšmiškais pranešimais, ypač dirbant be galvos aplinkoje be vizualinio grįžtamojo ryšio iš naršyklės.

Be to, bandymai gali būti vykdomi įvairiuose puslapiuose arba „JavaScript“ kontekstuose begalvis_chromas yra naudojamas. Galite užtikrinti, kad „JavaScript“ tinkamai veiktų įvairiose internetinėse programose, valdydami skirtingus skirtukus arba seansus. Tai gali sutaupyti daug laiko derinant atskirus scenarijus, nes leidžia vienu metu tikrinti kelis galutinius taškus, ar nėra „JavaScript“ problemų integracijos testavimo situacijose.