ರಸ್ಟ್ ಮತ್ತು ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್ ಬಳಸಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲಾಗುತ್ತಿದೆ

ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್‌ನೊಂದಿಗೆ ರಸ್ಟ್‌ನಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಆನ್‌ಲೈನ್ ಆಟೊಮೇಷನ್ ಅಥವಾ ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಡೀಬಗ್ ಮಾಡಲು ಮತ್ತು ಕೋಡ್ ಸ್ಥಿರತೆಯನ್ನು ಖಾತರಿಪಡಿಸಲು JavaScript ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸುವುದು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ. ರಸ್ಟ್‌ನಲ್ಲಿ ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್ ಬ್ರೌಸರ್ ನಿದರ್ಶನದಲ್ಲಿ JavaScript ಅನ್ನು ರನ್ ಮಾಡಬಹುದು ಮತ್ತು ಮಾರ್ಪಡಿಸಬಹುದು ಧನ್ಯವಾದಗಳು ತಲೆಯಿಲ್ಲದ_ಕ್ರೋಮ್ ಕ್ರೇಟ್. ಆದಾಗ್ಯೂ, ದಸ್ತಾವೇಜನ್ನು ಕೊರತೆಯು JavaScript ಸಮಸ್ಯೆಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಈ ಕ್ರೇಟ್ ಅನ್ನು ಬಳಸಲು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ.

ಈ ಲೇಖನವನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮಸ್ಯೆಗಳನ್ನು ಹೇಗೆ ಗುರುತಿಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ ತಲೆಯಿಲ್ಲದ_ಕ್ರೋಮ್ ಕ್ರೇಟ್ ಇನ್ ರಸ್ಟ್, ಸ್ಕ್ರಿಪ್ಟ್ ವಿಫಲಗೊಳ್ಳುವ ಸನ್ನಿವೇಶಗಳನ್ನು ನಿರ್ವಹಿಸುವುದರ ಮೇಲೆ ಒತ್ತು ನೀಡುತ್ತದೆ. ವಿಫಲವಾದ ಸಮರ್ಥನೆಗಳಂತಹ ಸಮಸ್ಯೆಗಳಿಗೆ ಕಣ್ಣಿಡಲು Chrome ನಲ್ಲಿ ಲಾಗಿಂಗ್ ಮತ್ತು ಡೀಬಗರ್ ಈವೆಂಟ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ನಾವು ನಿರ್ದಿಷ್ಟವಾಗಿ ನೋಡುತ್ತೇವೆ.

ನಿರ್ದಿಷ್ಟ ರೀತಿಯ JavaScript ವೈಫಲ್ಯಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ರಸ್ಟ್‌ನಲ್ಲಿ ಈವೆಂಟ್ ಕೇಳುಗರನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸುವುದು ಡೆವಲಪರ್‌ಗಳು ಎದುರಿಸುತ್ತಿರುವ ತೊಂದರೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ನಾವು ನೋಡುವಂತೆ, ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವ ಮೊದಲು ಕೆಲವು ಸೆಟಪ್ ಅಗತ್ಯವಾಗಬಹುದು console.assert(false) ಪತ್ತೆಹಚ್ಚಬಹುದಾದ ಘಟನೆಗಳನ್ನು ತಕ್ಷಣವೇ ಸೃಷ್ಟಿಸಲು; ಇದು ರಸ್ಟ್‌ನ ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಸಾಮರ್ಥ್ಯಗಳ ಆಳವಾದ ಗ್ರಹಿಕೆಗೆ ಕರೆ ನೀಡುತ್ತದೆ.

ನಾವು ಕೋಡ್ ಮಾದರಿಗಳ ಮೂಲಕ ಹೋಗುತ್ತೇವೆ, ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತೇವೆ ಮತ್ತು ಮುಂಬರುವ ಭಾಗಗಳಲ್ಲಿ JavaScript ದೋಷಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹಿಡಿಯಲು ನಮ್ಮ ಈವೆಂಟ್ ಕೇಳುಗರನ್ನು ಸುಧಾರಿಸುತ್ತೇವೆ. ಸಂಪೂರ್ಣ ದಾಖಲಾತಿಯನ್ನು ಹೊಂದಿರದ ಕ್ರೇಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹೇಗೆ ಪ್ರಯೋಗ ಮತ್ತು ದೋಷದ ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ಈ ವಿಧಾನವು ತೋರಿಸುತ್ತದೆ.

ರಸ್ಟ್‌ನ ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್ ಕ್ರೇಟ್‌ನೊಂದಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಹೇಗೆ

ರಸ್ಟ್ ಕ್ರೇಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಉದ್ದೇಶವಾಗಿದೆ ತಲೆಯಿಲ್ಲದ_ಕ್ರೋಮ್ ಮತ್ತು ಉದ್ಭವಿಸುವ ಯಾವುದೇ JavaScript ಸಮಸ್ಯೆಗಳನ್ನು ಗುರುತಿಸಿ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಉದ್ದೇಶಿಸಿದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ವೆಬ್ ಸ್ಕ್ರ್ಯಾಪಿಂಗ್ ಅಥವಾ ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆಯನ್ನು ಬಳಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿದೆ. ಬಳಸುತ್ತಿದೆ ಬ್ರೌಸರ್::ಹೊಸ, ಸ್ಕ್ರಿಪ್ಟ್ ಮೊದಲು ಬ್ರೌಸರ್‌ನ ಹೊಸ ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ ಮತ್ತು ಕೆಲವನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಲಾಂಚ್ ಆಯ್ಕೆಗಳು, ಉದಾಹರಣೆಗೆ ವಿಂಡೋ ಗಾತ್ರ. ಹೆಡ್‌ಲೆಸ್ ಕ್ರೋಮ್ ನಿದರ್ಶನವು ನಿಜವಾದ ಬ್ರೌಸರ್ ಪರಿಸರದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ಈ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ರವಾನಿಸಲಾಗಿದೆ.

ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುತ್ತದೆ tab.new_tab() ಬ್ರೌಸರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ ಹೊಸ ಟ್ಯಾಬ್ ಅನ್ನು ರಚಿಸಲು. ಈ ಟ್ಯಾಬ್ ಬ್ರೌಸರ್ ವಿಂಡೋವನ್ನು ಹೋಲುವ ರೀತಿಯಲ್ಲಿ JavaScript ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ. ಬಳಸುವ ಮೂಲಕ ನಾವು JavaScript ದೋಷಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ನಿರ್ಣಾಯಕ ಘಟನೆಗಳನ್ನು ಆಲಿಸಬಹುದು tab.enable_debugger() ಮತ್ತು tab.enable_log() Chrome ಡೀಬಗರ್ ಮತ್ತು ಲಾಗಿಂಗ್ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಈ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಆನ್ ಮಾಡುವುದರಿಂದ Chrome ನ ಅಂತರ್ನಿರ್ಮಿತ ಡೀಬಗ್ ಮಾಡುವ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬಳಸಲು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಇದು ಸಾಂಪ್ರದಾಯಿಕ ಲಾಗಿಂಗ್ ವಿಧಾನಗಳ ಮೂಲಕ ಸ್ಪಷ್ಟವಾಗಿ ಕಂಡುಬರದ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲು ಅವಶ್ಯಕವಾಗಿದೆ.

ಮುಂದೆ, ದಿ tab.add_event_listener() ಈವೆಂಟ್ ಕೇಳುಗರನ್ನು ಬಳಸಿಕೊಳ್ಳಲು ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ವಿಧಾನವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಕಾರ್ಯವು ನಿರ್ದಿಷ್ಟ ಡೀಬಗ್ ಮಾಡುವ ಘಟನೆಗಳನ್ನು ರೆಕಾರ್ಡ್ ಮಾಡಲು ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುತ್ತದೆ ಡೀಬಗರ್ ವಿರಾಮಗೊಳಿಸಲಾಗಿದೆ, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮಸ್ಯೆ ಅಥವಾ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ನಿಂದಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಅಡಚಣೆಯಾಗಿದೆ ಎಂಬ ಸೂಚನೆಯಾಗಿದೆ. ಈವೆಂಟ್ ಕೇಳುಗರು ಇದನ್ನು ರಸ್ಟ್ ಮುಚ್ಚುವಿಕೆಯಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ JavaScript ದೋಷವಿದೆಯೇ ಎಂದು ನಿರ್ಧರಿಸುತ್ತಾರೆ. ದೋಷ ಕಂಡುಬಂದರೆ ಸಾಫ್ಟ್‌ವೇರ್ ಪ್ಯಾನಿಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ದೋಷ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಈ ವಿಧಾನದಿಂದ, ತಲೆಯಿಲ್ಲದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ ಸಹ, ನೈಜ ಸಮಯದಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ಹಿಡಿಯಲಾಗುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, tab.evaluate() ನೇರವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಹೇಳಿಕೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ, console.assert(false). ವಿಫಲವಾದ ಸಮರ್ಥನೆ ಅಥವಾ ಇತರ JavaScript ಸಮಸ್ಯೆಯನ್ನು ಸೆರೆಹಿಡಿಯಬೇಕಾದ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸಾಮಾನ್ಯ ಸನ್ನಿವೇಶವನ್ನು ಅನುಕರಿಸಲು, ಈ ಆಜ್ಞೆಯು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ದೋಷವನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಸಮಸ್ಯೆ ಉಂಟಾದಾಗ, ಡೆವಲಪರ್‌ಗಳು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸಬಹುದು ಮತ್ತು ದೋಷ ಪತ್ತೆ ಮತ್ತು ಡೀಬಗರ್ ಅನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ ಎಚ್ಚರಿಕೆಯನ್ನು ಪ್ರಚೋದಿಸಬಹುದು. ಕೊನೆಯದಾಗಿ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರನ್ ಆಗಲು ಸ್ಕ್ರಿಪ್ಟ್ ಸಾಕಷ್ಟು ಸಮಯ ಕಾಯುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳ ಬಳಕೆಯನ್ನು ಕೊನೆಗೊಳಿಸುವ ಮೊದಲು ರೆಕಾರ್ಡ್ ಮಾಡಲು ಎಸ್ಟಿಡಿ::ಥ್ರೆಡ್::ಸ್ಲೀಪ್().

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!");
    }
}

ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ನೊಂದಿಗೆ ರಸ್ಟ್‌ನಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷ ಪತ್ತೆಯನ್ನು ಹೆಚ್ಚಿಸುವುದು

ಮೂಲ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ದೋಷಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ ತಲೆಯಿಲ್ಲದ_ಕ್ರೋಮ್ ಪ್ಯಾಕೇಜ್, ದೋಷ-ನಿರ್ವಹಣೆ ದಕ್ಷತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸುವುದು ಸಹ ಅತ್ಯಗತ್ಯ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಈವೆಂಟ್ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸುವುದು Runtime.exception ಥ್ರೋನ್ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುಧಾರಿಸಲು ಒಂದು ವಿಧಾನವಾಗಿದೆ. JavaScript ವಿನಾಯಿತಿಗಳ ಕುರಿತು ಹೆಚ್ಚಿನ ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು ಈ ಪ್ರೋಟೋಕಾಲ್ ಈವೆಂಟ್‌ನಿಂದ ಪಡೆಯಬಹುದು, ಈ ವೈಫಲ್ಯಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಿರ್ವಾಹಕರಿಗೆ ಹೆಚ್ಚು ನಿಖರವಾದ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ. ರನ್‌ಟೈಮ್ ವಿನಾಯಿತಿಗಳು ಅಥವಾ ತಪ್ಪಾದ ಕೋಡ್‌ನಿಂದಾಗಿ ದೋಷಗಳು ಉತ್ಪತ್ತಿಯಾಗುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈವೆಂಟ್ ಕೇಳುಗರು ಸರಳವಾದ ಸಮರ್ಥನೆಯ ವೈಫಲ್ಯಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸಬಹುದು.

ಡೀಬಗ್ ಮಾಡುವ ಈವೆಂಟ್‌ಗಳಿಗೆ ಕಿವಿಗೊಡುವುದರ ಜೊತೆಗೆ ರಸ್ಟ್‌ನೊಂದಿಗೆ ತಪ್ಪುಗಳನ್ನು ಆಕರ್ಷಕವಾಗಿ ನಿರ್ವಹಿಸುವುದು ಬಹಳ ಮುಖ್ಯ. ಉದಾಹರಣೆಗೆ, ರಸ್ಟ್ ನ ಫಲಿತಾಂಶ ಮತ್ತು ಆಯ್ಕೆ ಬೆಸ್ಪೋಕ್ ದೋಷ ಪ್ರಕಾರಗಳನ್ನು ರಚಿಸಲು ಡೆವಲಪರ್‌ಗಳು ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಬಹುದು. ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವೈಫಲ್ಯಗಳಿಂದ ಸುಧಾರಿತ ದೋಷ ಪ್ರಸರಣ ಮತ್ತು ಮರುಪಡೆಯುವಿಕೆಯನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ರಸ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಹೆಚ್ಚು ದೃಢವಾಗಿಸುತ್ತದೆ. ದೋಷಗಳನ್ನು ನಿಸ್ಸಂದಿಗ್ಧ ಸಂದೇಶಗಳೊಂದಿಗೆ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಲಾಗ್ ಮಾಡುವ ಮೂಲಕ ಅವುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸಬಹುದು, ವಿಶೇಷವಾಗಿ ಬ್ರೌಸರ್‌ನಿಂದ ದೃಶ್ಯ ಪ್ರತಿಕ್ರಿಯೆಯಿಲ್ಲದೆ ತಲೆಯಿಲ್ಲದ ವಾತಾವರಣದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವಾಗ.

ಇದಲ್ಲದೆ, ಪರೀಕ್ಷೆಗಳನ್ನು ವಿವಿಧ ಪುಟಗಳಲ್ಲಿ ಅಥವಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಡೆಸಬಹುದು ತಲೆಯಿಲ್ಲದ_ಕ್ರೋಮ್ ಬಳಸಲಾಗುತ್ತದೆ. ವಿಭಿನ್ನ ಟ್ಯಾಬ್‌ಗಳು ಅಥವಾ ಸೆಷನ್‌ಗಳನ್ನು ನಿಯಂತ್ರಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿವಿಧ ಆನ್‌ಲೈನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು. ಏಕೀಕರಣ ಪರೀಕ್ಷೆಯ ಸಂದರ್ಭಗಳಲ್ಲಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮಸ್ಯೆಗಳಿಗೆ ಏಕಕಾಲದಲ್ಲಿ ಹಲವಾರು ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಪರೀಕ್ಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುವ ಮೂಲಕ ಪ್ರತ್ಯೇಕ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡುವಾಗ ಇದು ಸಾಕಷ್ಟು ಸಮಯವನ್ನು ಉಳಿಸಬಹುದು.