Network interception (CDP) in Selenium Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Selenium CDP network interception code?

Consider the following Java Selenium code snippet using Chrome DevTools Protocol (CDP) to intercept network requests and block images. What will be the output printed to the console?

Selenium Java

DevTools devTools = driver.getDevTools();
devTools.createSession();

// Enable Network domain
devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));

// Block image requests
devTools.send(Network.setBlockedURLs(List.of("*://*.png", "*://*.jpg")));

// Add listener to print request URLs
devTools.addListener(Network.requestWillBeSent(), request -> {
    System.out.println("Request URL: " + request.getRequest().getUrl());
});

// Navigate to a page with images
driver.get("https://example.com");

System.out.println("Page loaded");

A Request URLs printed for all resources including images; then 'Page loaded' printed

B Request URLs printed for all resources except images; then 'Page loaded' printed

C No request URLs printed; only 'Page loaded' printed

D Throws runtime exception due to missing permissions

💡 Hint

Think about what Network.setBlockedURLs does and how listeners behave.

The code blocks image requests by URL patterns (*://*.png, *://*.jpg). The listener prints URLs of requests that are sent. Since images are blocked, their requests are not sent, so their URLs are not printed. Finally, 'Page loaded' is printed after navigation.

❓ assertion

intermediate

Which assertion correctly verifies a blocked image request using Selenium CDP?

You want to assert that an image request was blocked by CDP network interception. Which assertion correctly checks this in Java?

Selenium Java

AtomicBoolean imageBlocked = new AtomicBoolean(false);
devTools.addListener(Network.loadingFailed(), loadingFailed -> {
    if (loadingFailed.getType() == ResourceType.IMAGE && loadingFailed.getBlockedReason() != null) {
        imageBlocked.set(true);
    }
});

// Trigger page load with images
// ...

// Which assertion below is correct?

A assertFalse(imageBlocked.get(), "Image request was blocked");

B assertNull(imageBlocked.get(), "Image request was blocked");

C assertTrue(imageBlocked.get(), "Image request was blocked");

D assertEquals(false, imageBlocked.get(), "Image request was blocked");

💡 Hint

Think about what imageBlocked represents after the listener runs.

The imageBlocked flag is set to true if an image request failed due to blocking. To verify blocking, assert that this flag is true.

🔧 Debug

advanced

Why does this Selenium CDP network interception code not block images as expected?

Review the following code snippet intended to block image requests. Why does it fail to block images?

Selenium Java

DevTools devTools = driver.getDevTools();
devTools.createSession();

// Enable Network domain
devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));

// Attempt to block images
devTools.send(Network.setBlockedURLs(List.of("*.png", "*.jpg")));

// Navigate to page
driver.get("https://example.com");

A The URL patterns '*.png' and '*.jpg' are invalid; they must be full URLs or regex

B Network.setBlockedURLs must be called before Network.enable

C The driver does not support CDP commands

D The session was not created before sending commands

💡 Hint

Check the format expected by setBlockedURLs for URL patterns.

The setBlockedURLs method expects URL patterns with scheme and domain parts or valid wildcards. Patterns like '*.png' are not valid and do not match requests, so images are not blocked.

❓ framework

advanced

Which Selenium Java code snippet correctly sets up CDP network interception to modify request headers?

You want to add a custom header to all outgoing HTTP requests using Selenium CDP in Java. Which code snippet correctly achieves this?

A

devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));
devTools.send(Network.setBlockedURLs(List.of("*")));
driver.get("https://example.com");

B

devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));
devTools.addListener(Network.requestWillBeSent(), event -> {
    Map<String, Object> headers = new HashMap<>(event.getRequest().getHeaders());
    headers.put("X-Custom-Header", "MyValue");
    devTools.send(Network.setExtraHTTPHeaders(new Headers(headers)));
});

C

devTools.createSession();
devTools.send(Network.setExtraHTTPHeaders(new Headers(Map.of("X-Custom-Header", "MyValue"))));
driver.get("https://example.com");

D

devTools.createSession();
devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty()));
Map<String, String> headers = Map.of("X-Custom-Header", "MyValue");
devTools.send(Network.setExtraHTTPHeaders(new Headers(headers)));
driver.get("https://example.com");

💡 Hint

Consider when and how to set extra HTTP headers for all requests.

Option D creates a session, enables the Network domain, sets the extra HTTP headers once before navigation, which applies to all requests. Option D tries to set headers inside a listener, which is incorrect. Option D misses enabling Network domain. Option D blocks all URLs, unrelated to headers.

🧠 Conceptual

expert

What is the main advantage of using Selenium CDP network interception over traditional proxy-based interception?

Choose the best explanation for why Selenium's CDP network interception is preferred over using an external proxy for network control in browser automation.

A CDP network interception integrates directly with the browser, providing lower latency and more accurate control without external dependencies

B Proxy-based interception is faster and more reliable than CDP, so CDP is rarely used

C CDP requires no browser support and works with all browsers equally

D Proxy-based interception can modify requests, but CDP cannot

💡 Hint

Think about integration level and performance.

CDP works inside the browser's own debugging protocol, allowing precise and fast interception without needing external proxy setup. Proxy-based methods add network hops and complexity.