ਜੰਗਾਲ ਅਤੇ ਸਿਰ ਰਹਿਤ ਕਰੋਮ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣਾ

ਹੈੱਡਲੈੱਸ ਕਰੋਮ ਨਾਲ ਜੰਗਾਲ ਵਿੱਚ JavaScript ਗਲਤੀਆਂ ਨੂੰ ਸੰਭਾਲਣਾ

ਔਨਲਾਈਨ ਆਟੋਮੇਸ਼ਨ ਜਾਂ ਟੈਸਟਿੰਗ ਨਾਲ ਨਜਿੱਠਣ ਵੇਲੇ ਡੀਬੱਗਿੰਗ ਅਤੇ ਕੋਡ ਸਥਿਰਤਾ ਦੀ ਗਰੰਟੀ ਦੇਣ ਲਈ JavaScript ਮੁੱਦਿਆਂ ਦੀ ਪਛਾਣ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ। ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਰਸਟ ਵਿੱਚ ਇੱਕ ਹੈੱਡਲੈੱਸ ਕ੍ਰੋਮ ਬਰਾਊਜ਼ਰ ਉਦਾਹਰਨ ਦੇ ਅੰਦਰ ਚਲਾਇਆ ਅਤੇ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ। headless_chrome ਕਰੇਟ ਹਾਲਾਂਕਿ, ਦਸਤਾਵੇਜ਼ਾਂ ਦੀ ਘਾਟ JavaScript ਮੁੱਦਿਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਇਸ ਕਰੇਟ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਮੁਸ਼ਕਲ ਬਣਾਉਂਦੀ ਹੈ।

ਇਹ ਲੇਖ ਦੱਸਦਾ ਹੈ ਕਿ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਿਵੇਂ ਪਛਾਣ ਕਰਨੀ ਹੈ headless_chrome ਜੰਗਾਲ ਵਿੱਚ crate, ਦ੍ਰਿਸ਼ਾਂ ਦੇ ਪ੍ਰਬੰਧਨ 'ਤੇ ਜ਼ੋਰ ਦੇ ਨਾਲ, ਜਿਸ ਵਿੱਚ ਇੱਕ ਸਕ੍ਰਿਪਟ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਖਾਸ ਤੌਰ 'ਤੇ ਦੇਖਾਂਗੇ ਕਿ ਕ੍ਰੋਮ ਵਿੱਚ ਲੌਗਿੰਗ ਅਤੇ ਡੀਬਗਰ ਇਵੈਂਟਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਨੀ ਹੈ ਤਾਂ ਜੋ ਅਸਫਲ ਦਾਅਵੇ ਵਰਗੀਆਂ ਸਮੱਸਿਆਵਾਂ 'ਤੇ ਨਜ਼ਰ ਰੱਖੀ ਜਾ ਸਕੇ।

ਖਾਸ ਕਿਸਮ ਦੀਆਂ JavaScript ਅਸਫਲਤਾਵਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਰਸਟ ਵਿੱਚ ਇਵੈਂਟ ਸਰੋਤਿਆਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈੱਟ ਕਰਨਾ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਦਰਪੇਸ਼ ਮੁਸ਼ਕਲਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖਾਂਗੇ, ਜਿਵੇਂ ਕਿ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਰੁਜ਼ਗਾਰ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਕੁਝ ਸੈੱਟਅੱਪ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ console.asssert(ਗਲਤ) ਤੁਰੰਤ ਖੋਜਣਯੋਗ ਘਟਨਾਵਾਂ ਪੈਦਾ ਕਰਨ ਲਈ; ਇਹ ਰਸਟ ਦੀ ਇਵੈਂਟ ਹੈਂਡਲਿੰਗ ਸਮਰੱਥਾਵਾਂ ਦੀ ਡੂੰਘੀ ਸਮਝ ਦੀ ਮੰਗ ਕਰਦਾ ਹੈ।

ਅਸੀਂ ਆਉਣ ਵਾਲੇ ਹਿੱਸਿਆਂ ਵਿੱਚ JavaScript ਗਲਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਫੜਨ ਲਈ ਕੋਡ ਦੇ ਨਮੂਨਿਆਂ ਵਿੱਚੋਂ ਲੰਘਾਂਗੇ, ਆਮ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਾਂਗੇ, ਅਤੇ ਸਾਡੇ ਇਵੈਂਟ ਸਰੋਤਿਆਂ ਨੂੰ ਬਿਹਤਰ ਬਣਾਵਾਂਗੇ। ਇਹ ਵਿਧੀ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਉਹਨਾਂ ਕ੍ਰੇਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਦਸਤਾਵੇਜ਼ ਨਹੀਂ ਹਨ, ਅਜ਼ਮਾਇਸ਼ ਅਤੇ ਗਲਤੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਜੰਗਾਲ ਦੇ ਹੈੱਡਲੈੱਸ ਕ੍ਰੋਮ ਕ੍ਰੇਟ ਨਾਲ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਗਲਤੀਆਂ ਨੂੰ ਕਿਵੇਂ ਖੋਜਿਆ ਜਾਵੇ

ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਉਦੇਸ਼ ਰਸਟ ਕਰੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹੈੱਡਲੈੱਸ ਕ੍ਰੋਮ ਬ੍ਰਾਊਜ਼ਰ ਦੇ ਅੰਦਰ JavaScript ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਹੈ headless_chrome ਅਤੇ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ JavaScript ਮੁੱਦੇ ਦੀ ਪਛਾਣ ਕਰੋ। ਇਹ ਖਾਸ ਤੌਰ 'ਤੇ ਮਦਦਗਾਰ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਵੈਬ ਸਕ੍ਰੈਪਿੰਗ ਜਾਂ ਸਵੈਚਲਿਤ ਟੈਸਟਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ JavaScript ਇਰਾਦੇ ਮੁਤਾਬਕ ਕੰਮ ਕਰਦੀ ਹੈ। ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬਰਾਊਜ਼ਰ::ਨਵਾਂ, ਸਕ੍ਰਿਪਟ ਪਹਿਲਾਂ ਬ੍ਰਾਊਜ਼ਰ ਦੀ ਇੱਕ ਨਵੀਂ ਉਦਾਹਰਨ ਸ਼ੁਰੂ ਕਰਦੀ ਹੈ ਅਤੇ ਕੁਝ ਸੈੱਟ ਕਰਦੀ ਹੈ ਲਾਂਚ ਵਿਕਲਪ, ਜਿਵੇਂ ਕਿ ਵਿੰਡੋ ਦਾ ਆਕਾਰ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਸਿਰਲੇਖ ਰਹਿਤ ਕ੍ਰੋਮ ਉਦਾਹਰਨ ਅਸਲ ਬ੍ਰਾਊਜ਼ਰ ਵਾਤਾਵਰਨ ਵਾਂਗ ਕੰਮ ਕਰੇ, ਇਹ ਸੈਟਿੰਗਾਂ ਪਾਸ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ।

ਸਕ੍ਰਿਪਟ ਵਰਤਦਾ ਹੈ tab.new_tab() ਬ੍ਰਾਊਜ਼ਰ ਸ਼ੁਰੂ ਹੋਣ ਤੋਂ ਬਾਅਦ ਇੱਕ ਨਵੀਂ ਟੈਬ ਬਣਾਉਣ ਲਈ। ਇਹ ਟੈਬ JavaScript ਨੂੰ ਬ੍ਰਾਊਜ਼ਰ ਵਿੰਡੋ ਵਾਂਗ ਹੀ ਚਲਾਉਂਦੀ ਹੈ। ਅਸੀਂ ਵਰਤ ਕੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਦੀਆਂ ਗਲਤੀਆਂ ਸਮੇਤ ਮਹੱਤਵਪੂਰਨ ਘਟਨਾਵਾਂ ਨੂੰ ਸੁਣ ਸਕਦੇ ਹਾਂ tab.enable_debugger() ਅਤੇ tab.enable_log() ਕਰੋਮ ਡੀਬਗਰ ਅਤੇ ਲੌਗਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸਮਰੱਥ ਕਰਨ ਲਈ। ਖਾਸ ਤੌਰ 'ਤੇ, ਇਹਨਾਂ ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਚਾਲੂ ਕਰਨਾ ਸਕ੍ਰਿਪਟ ਨੂੰ Chrome ਦੇ ਬਿਲਟ-ਇਨ ਡੀਬਗਿੰਗ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਯੋਗ ਬਣਾਉਂਦਾ ਹੈ, ਜੋ ਕਿ ਉਹਨਾਂ ਨੁਕਸਾਂ ਨੂੰ ਫੜਨ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜੋ ਸ਼ਾਇਦ ਰਵਾਇਤੀ ਲੌਗਿੰਗ ਵਿਧੀਆਂ ਦੁਆਰਾ ਸਪੱਸ਼ਟ ਨਾ ਹੋਣ।

ਅੱਗੇ, ਦ tab.add_event_listener() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਸਕ੍ਰਿਪਟ ਦੁਆਰਾ ਇੱਕ ਘਟਨਾ ਸੁਣਨ ਵਾਲੇ ਨੂੰ ਨਿਯੁਕਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਖਾਸ ਡੀਬਗਿੰਗ ਇਵੈਂਟਸ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਲਈ ਇੱਕ ਸਿਸਟਮ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਡੀਬੱਗਰ ਰੋਕਿਆ ਗਿਆ, ਜੋ ਕਿ ਇੱਕ ਸੰਕੇਤ ਹੈ ਕਿ ਇੱਕ JavaScript ਸਮੱਸਿਆ ਜਾਂ ਬ੍ਰੇਕਪੁਆਇੰਟ ਦੇ ਕਾਰਨ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਵਿੱਚ ਰੁਕਾਵਟ ਆਈ ਹੈ। ਇਵੈਂਟ ਲਿਸਨਰ ਇਹ ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਇਸ ਨੂੰ ਇੱਕ ਜੰਗਾਲ ਬੰਦ ਵਿੱਚ ਨੱਥੀ ਕਰਕੇ JavaScript ਗਲਤੀ ਹੋਈ ਹੈ। ਸੌਫਟਵੇਅਰ ਘਬਰਾਏਗਾ ਅਤੇ ਇੱਕ ਗਲਤੀ ਸੁਨੇਹਾ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰੇਗਾ ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਮਿਲਦੀ ਹੈ. ਇਸ ਵਿਧੀ ਨਾਲ, ਬਿਨਾਂ ਸਿਰ ਦੇ ਕੰਮ ਕਰਦੇ ਹੋਏ ਵੀ, JavaScript ਦੀਆਂ ਗਲਤੀਆਂ ਅਸਲ ਸਮੇਂ ਵਿੱਚ ਫੜੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਅੰਤ ਵਿੱਚ, tab.evaluate() ਇੱਕ ਸਿੱਧੇ ਜਾਵਾ ਸਕ੍ਰਿਪਟ ਸਟੇਟਮੈਂਟ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, console.asssert(ਗਲਤ). ਵੈੱਬ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਇੱਕ ਆਮ ਦ੍ਰਿਸ਼ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਜਿੱਥੇ ਇੱਕ ਅਸਫਲ ਦਾਅਵਾ ਜਾਂ ਹੋਰ JavaScript ਮੁੱਦੇ ਨੂੰ ਕੈਪਚਰ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ, ਇਹ ਕਮਾਂਡ ਜਾਣਬੁੱਝ ਕੇ ਇੱਕ ਗਲਤੀ ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ। ਜਦੋਂ ਕੋਈ ਸਮੱਸਿਆ ਆਉਂਦੀ ਹੈ, ਤਾਂ ਡਿਵੈਲਪਰ ਆਪਣੇ ਆਪ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕ ਸਕਦੇ ਹਨ ਅਤੇ ਗਲਤੀ ਖੋਜ ਅਤੇ ਡੀਬਗਰ ਨੂੰ ਜੋੜ ਕੇ ਇੱਕ ਅਲਾਰਮ ਨੂੰ ਟਰਿੱਗਰ ਕਰ ਸਕਦੇ ਹਨ। ਅੰਤ ਵਿੱਚ, ਸਕ੍ਰਿਪਟ JavaScript ਦੇ ਚੱਲਣ ਲਈ ਕਾਫ਼ੀ ਲੰਬਾ ਇੰਤਜ਼ਾਰ ਕਰਦੀ ਹੈ ਅਤੇ ਵਰਤੋਂ ਨੂੰ ਖਤਮ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਕਿਸੇ ਵੀ ਸਮੱਸਿਆ ਨੂੰ ਰਿਕਾਰਡ ਕਰਨ ਲਈ ਧੰਨਵਾਦ ਕਰਦੀ ਹੈ। 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 ਗਲਤੀ ਖੋਜ ਨੂੰ ਵਧਾਉਣਾ

ਜਦੋਂ ਕਿ ਮੂਲ ਸਕ੍ਰਿਪਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ JavaScript ਨੁਕਸ ਦਾ ਪਤਾ ਲਗਾਉਣ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ headless_chrome ਪੈਕੇਜ, ਗਲਤੀ-ਪ੍ਰਬੰਧਨ ਕੁਸ਼ਲਤਾ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਵੀ ਜ਼ਰੂਰੀ ਹੈ। ਹੋਰ ਗੁੰਝਲਦਾਰ ਇਵੈਂਟ ਕਿਸਮਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਿਵੇਂ ਕਿ Runtime.exceptionTrown ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਬਿਹਤਰ ਬਣਾਉਣ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ। JavaScript ਅਪਵਾਦਾਂ ਬਾਰੇ ਵਧੇਰੇ ਖਾਸ ਜਾਣਕਾਰੀ ਇਸ ਪ੍ਰੋਟੋਕੋਲ ਇਵੈਂਟ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਪ੍ਰਸ਼ਾਸਕਾਂ ਨੂੰ ਇਹਨਾਂ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਨਜਿੱਠਿਆ ਜਾਂਦਾ ਹੈ ਇਸ ਬਾਰੇ ਵਧੇਰੇ ਸਟੀਕ ਨਿਯੰਤਰਣ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਹ ਇਵੈਂਟ ਲਿਸਨਰ ਉਹਨਾਂ ਸਥਿਤੀਆਂ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਦਾਅਵੇ ਦੀ ਅਸਫਲਤਾ ਨਾਲੋਂ ਵਧੇਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਰਨਟਾਈਮ ਅਪਵਾਦਾਂ ਜਾਂ ਗਲਤ ਕੋਡ ਦੇ ਕਾਰਨ ਗਲਤੀਆਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ।

ਡੀਬੱਗਿੰਗ ਇਵੈਂਟਾਂ ਲਈ ਕੰਨਾਂ ਨੂੰ ਬਾਹਰ ਰੱਖਣ ਦੇ ਨਾਲ-ਨਾਲ ਰਸਟ ਨਾਲ ਗਲਤੀਆਂ ਨੂੰ ਸੁੰਦਰਤਾ ਨਾਲ ਸੰਭਾਲਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੰਗਾਲ ਨਤੀਜਾ ਅਤੇ ਵਿਕਲਪ ਕਿਸਮਾਂ ਨੂੰ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਬੇਸਪੋਕ ਗਲਤੀ ਕਿਸਮਾਂ ਬਣਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ JavaScript ਅਸਫਲਤਾਵਾਂ ਤੋਂ ਸੁਧਾਰੀ ਗਲਤੀ ਦੇ ਪ੍ਰਸਾਰ ਅਤੇ ਰਿਕਵਰੀ ਨੂੰ ਸਮਰੱਥ ਕਰਕੇ ਤੁਹਾਡੀਆਂ ਜੰਗਾਲ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਹੋਰ ਮਜ਼ਬੂਤ ​​ਬਣਾਉਂਦਾ ਹੈ। ਅਸਪਸ਼ਟ ਸੁਨੇਹਿਆਂ ਦੇ ਨਾਲ ਕੰਸੋਲ ਵਿੱਚ ਲੌਗਇਨ ਕਰਕੇ ਗਲਤੀਆਂ ਨੂੰ ਵਧੇਰੇ ਤੇਜ਼ੀ ਨਾਲ ਪਛਾਣਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਜਦੋਂ ਬ੍ਰਾਊਜ਼ਰ ਤੋਂ ਵਿਜ਼ੂਅਲ ਫੀਡਬੈਕ ਦੇ ਬਿਨਾਂ ਹੈੱਡਲੈੱਸ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟੈਸਟ ਵੱਖ-ਵੱਖ ਪੰਨਿਆਂ ਜਾਂ JavaScript ਸੰਦਰਭਾਂ 'ਤੇ ਚਲਾਏ ਜਾ ਸਕਦੇ ਹਨ ਜਦੋਂ headless_chrome ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ. ਤੁਸੀਂ ਇਹ ਯਕੀਨੀ ਬਣਾ ਸਕਦੇ ਹੋ ਕਿ ਤੁਹਾਡੀ JavaScript ਵੱਖ-ਵੱਖ ਟੈਬਾਂ ਜਾਂ ਸੈਸ਼ਨਾਂ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਕੇ ਵੱਖ-ਵੱਖ ਔਨਲਾਈਨ ਐਪਾਂ ਵਿੱਚ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦੀ ਹੈ। ਏਕੀਕਰਣ ਟੈਸਟਿੰਗ ਸਥਿਤੀਆਂ ਵਿੱਚ ਤੁਹਾਨੂੰ JavaScript ਸਮੱਸਿਆਵਾਂ ਲਈ ਇੱਕੋ ਸਮੇਂ ਕਈ ਅੰਤਮ ਬਿੰਦੂਆਂ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਆਗਿਆ ਦੇ ਕੇ ਵਿਅਕਤੀਗਤ ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਵੇਲੇ ਇਹ ਬਹੁਤ ਸਾਰਾ ਸਮਾਂ ਬਚਾ ਸਕਦਾ ਹੈ।