tessl/maven-org-seleniumhq-selenium--selenium-remote-driver

WebDriver remote communication library that provides the core infrastructure for browser automation across different platforms and programming languages.

—

Pending

Overview

Eval results

Files

HTTP Communication

Name: tessl/maven-org-seleniumhq-selenium--selenium-remote-driver
Author: tessl

Comprehensive HTTP client infrastructure with support for WebSocket connections, request/response handling, routing, and connection management. This system provides the transport layer for all WebDriver communications and includes advanced features like filtering, routing, and real-time messaging.

Capabilities

HttpClient Interface

Core HTTP client interface providing both synchronous and asynchronous request capabilities, along with WebSocket support.

/**
 * HTTP client interface for WebDriver communications
 */
public interface HttpClient extends Closeable {
    
    /**
     * Execute HTTP request synchronously
     * @param req The HTTP request to execute
     * @return HTTP response
     */
    HttpResponse execute(HttpRequest req);
    
    /**
     * Execute HTTP request asynchronously
     * @param req The HTTP request to execute
     * @return CompletableFuture containing the HTTP response
     */
    CompletableFuture<HttpResponse> executeAsync(HttpRequest req);
    
    /**
     * Open WebSocket connection
     * @param request HTTP request for WebSocket upgrade
     * @param listener WebSocket event listener
     * @return WebSocket instance
     */
    WebSocket openSocket(HttpRequest request, WebSocket.Listener listener);
    
    void close();
    
    /**
     * Factory interface for creating HTTP clients
     */
    interface Factory {
        HttpClient createClient(ClientConfig config);
    }
    
    // Static factory methods
    static Factory create(String name);
    static Factory createDefault();
}

Usage Examples:

import org.openqa.selenium.remote.http.HttpClient;
import org.openqa.selenium.remote.http.HttpRequest;
import org.openqa.selenium.remote.http.HttpResponse;
import org.openqa.selenium.remote.http.ClientConfig;

// Create HTTP client
HttpClient.Factory factory = HttpClient.createDefault();
ClientConfig config = ClientConfig.defaultConfig()
    .baseUrl(new URL("http://localhost:4444"));
HttpClient client = factory.createClient(config);

// Synchronous request
HttpRequest request = new HttpRequest(HttpMethod.GET, "/status");
HttpResponse response = client.execute(request);

// Asynchronous request
CompletableFuture<HttpResponse> futureResponse = client.executeAsync(request);
HttpResponse asyncResponse = futureResponse.get();

// Cleanup
client.close();

ClientConfig

HTTP client configuration for connection settings, timeouts, filters, and base URLs.

/**
 * Configuration for HTTP clients
 */
public class ClientConfig {
    
    // Factory method
    public static ClientConfig defaultConfig();
    
    // Configuration methods
    public ClientConfig baseUrl(URL baseUrl);
    public ClientConfig baseUrl(URI baseUri);
    public ClientConfig withFilter(Filter filter);
    public ClientConfig readTimeout(Duration timeout);
    public ClientConfig connectionTimeout(Duration timeout);
    
    // Accessor methods
    public URL baseUrl();
    public URI baseUri();
    public Duration readTimeout();
    public Duration connectionTimeout();
    public Filter filter();
}

Usage Examples:

import org.openqa.selenium.remote.http.ClientConfig;
import org.openqa.selenium.remote.http.AddSeleniumUserAgent;
import java.time.Duration;

// Configure HTTP client
ClientConfig config = ClientConfig.defaultConfig()
    .baseUrl(new URL("http://selenium-grid:4444"))
    .readTimeout(Duration.ofSeconds(30))
    .connectionTimeout(Duration.ofSeconds(10))
    .withFilter(new AddSeleniumUserAgent());

HTTP Request/Response

Core HTTP message types for request/response communication.

/**
 * Represents an HTTP request
 */
public class HttpRequest extends HttpMessage<HttpRequest> {
    
    public HttpRequest(HttpMethod method, String uri);
    
    public HttpMethod getMethod();
    public String getUri();
    public String getQueryParameter(String name);
    public Iterable<String> getQueryParameterNames();
    public void setContent(Contents.Supplier content);
    public Contents.Supplier getContent();
}

/**
 * Represents an HTTP response
 */
public class HttpResponse extends HttpMessage<HttpResponse> {
    
    public int getStatus();
    public void setStatus(int status);
    public Iterable<String> getHeaderNames();
    public Iterable<String> getHeaders(String name);
    public String getHeader(String name);
    public void setHeader(String name, String value);
    public void addHeader(String name, String value);
    public void removeHeader(String name);
    public void setContent(Contents.Supplier content);
    public Contents.Supplier getContent();
}

/**
 * HTTP methods enumeration
 */
public enum HttpMethod {
    DELETE, GET, POST, PUT
}

Usage Examples:

import org.openqa.selenium.remote.http.*;

// Create HTTP request
HttpRequest request = new HttpRequest(HttpMethod.POST, "/session");
request.setHeader("Content-Type", "application/json");
request.setContent(Contents.utf8String("{\"capabilities\":{}}"));

// Add query parameters
String param = request.getQueryParameter("timeout");

// Process HTTP response
HttpResponse response = client.execute(request);
int status = response.getStatus();
String contentType = response.getHeader("Content-Type");
String body = Contents.string(response);

WebSocket Support

Real-time bidirectional communication support for advanced WebDriver features.

/**
 * WebSocket interface for real-time communication
 */
public interface WebSocket extends Closeable {
    
    WebSocket send(Message message);
    void close();
    void abort();
    
    /**
     * WebSocket event listener interface
     */
    interface Listener {
        void onOpen(WebSocket webSocket);
        void onText(CharSequence data);
        void onBinary(byte[] data);
        void onClose(int code, String reason);
        void onError(Throwable cause);
    }
}

/**
 * Base interface for WebSocket messages
 */
public interface Message {
}

/**
 * Text WebSocket message
 */
public class TextMessage implements Message {
    public TextMessage(String text);
    public String text();
}

/**
 * Binary WebSocket message
 */
public class BinaryMessage implements Message {
    public BinaryMessage(byte[] data);
    public byte[] data();
}

/**
 * WebSocket close message
 */
public class CloseMessage implements Message {
    public CloseMessage(int code, String reason);
    public int code();
    public String reason();
}

Usage Examples:

import org.openqa.selenium.remote.http.*;

// WebSocket listener implementation
WebSocket.Listener listener = new WebSocket.Listener() {
    @Override
    public void onOpen(WebSocket webSocket) {
        System.out.println("WebSocket opened");
        webSocket.send(new TextMessage("Hello Server"));
    }
    
    @Override
    public void onText(CharSequence data) {
        System.out.println("Received: " + data);
    }
    
    @Override
    public void onClose(int code, String reason) {
        System.out.println("WebSocket closed: " + code + " " + reason);
    }
    
    @Override
    public void onError(Throwable cause) {
        cause.printStackTrace();
    }
    
    @Override
    public void onBinary(byte[] data) {
        System.out.println("Received binary data of length: " + data.length);
    }
};

// Open WebSocket connection
HttpRequest wsRequest = new HttpRequest(HttpMethod.GET, "/ws");
WebSocket webSocket = client.openSocket(wsRequest, listener);

// Send messages
webSocket.send(new TextMessage("Hello"));
webSocket.send(new BinaryMessage("binary data".getBytes()));
webSocket.send(new CloseMessage(1000, "Normal closure"));

HTTP Filtering

Request/response filtering system for adding cross-cutting concerns like authentication, logging, and retry logic.

/**
 * HTTP request/response filter interface
 */
public interface Filter {
    HttpHandler apply(HttpHandler next);
}

/**
 * Functional interface for handling HTTP requests
 */
public interface HttpHandler {
    HttpResponse execute(HttpRequest req) throws UncheckedIOException;
}

Usage Examples:

import org.openqa.selenium.remote.http.*;

// Custom authentication filter
Filter authFilter = next -> req -> {
    req.setHeader("Authorization", "Bearer " + getToken());
    return next.execute(req);
};

// Logging filter
Filter loggingFilter = next -> req -> {
    System.out.println("Executing: " + req.getMethod() + " " + req.getUri());
    HttpResponse response = next.execute(req);
    System.out.println("Response: " + response.getStatus());
    return response;
};

// Use filters in client config
ClientConfig config = ClientConfig.defaultConfig()
    .withFilter(authFilter)
    .withFilter(loggingFilter);

Built-in Filters

Pre-built filters for common functionality.

/**
 * Filter to add Selenium user agent headers
 */
public class AddSeleniumUserAgent implements Filter {
    public HttpHandler apply(HttpHandler next);
}

/**
 * Filter for debugging HTTP exchanges
 */
public class DumpHttpExchangeFilter implements Filter {
    public DumpHttpExchangeFilter();
    public HttpHandler apply(HttpHandler next);
}

/**
 * Filter for HTTP request retries
 */
public class RetryRequest implements Filter {
    public RetryRequest();
    public HttpHandler apply(HttpHandler next);
}

HTTP Routing

URL routing and template matching system for handling HTTP requests.

/**
 * HTTP routing utilities
 */
public class Route implements HttpHandler, Routable {
    
    // Static factory methods
    public static Route matching(Predicate<HttpRequest> predicate);
    public static Route get(String template);
    public static Route post(String template);
    public static Route put(String template);
    public static Route delete(String template);
    
    // Configuration methods
    public Route to(Supplier<HttpHandler> handler);
    public Route to(HttpHandler handler);
    
    public HttpResponse execute(HttpRequest req);
}

/**
 * URL template matching and parsing
 */
public class UrlTemplate {
    
    public UrlTemplate(String template);
    
    public boolean match(String url);
    public Match match(HttpRequest request);
    public String expand(Map<String, Object> parameters);
    
    public static class Match {
        public Map<String, String> getParameters();
        public String getUrl();
    }
}

/**
 * URL path utilities
 */
public class UrlPath {
    
    public static UrlPath relativeUrl(String url);
    
    public String path();
    public Map<String, List<String>> parameters();
}

Usage Examples:

import org.openqa.selenium.remote.http.*;
import java.util.Map;

// URL template matching
UrlTemplate template = new UrlTemplate("/session/{sessionId}/element");
boolean matches = template.match("/session/abc123/element");
UrlTemplate.Match match = template.match(request);
Map<String, String> params = match.getParameters();
String sessionId = params.get("sessionId");

// HTTP routing
Route sessionRoute = Route.post("/session")
    .to(req -> {
        // Handle new session creation
        return new HttpResponse().setStatus(200);
    });

Route elementRoute = Route.get("/session/{sessionId}/element/{elementId}")
    .to(() -> new ElementHandler());

// Path utilities
UrlPath path = UrlPath.relativeUrl("/status?ready=true");
String pathString = path.path(); // "/status"
Map<String, List<String>> queryParams = path.parameters(); // {"ready": ["true"]}

HTTP Content Utilities

Utilities for handling HTTP request/response content in various formats.

/**
 * HTTP content utilities
 */
public class Contents {
    
    // Content factories
    public static Contents.Supplier utf8String(String text);
    public static Contents.Supplier bytes(byte[] bytes);
    public static Contents.Supplier empty();
    
    // Content extractors
    public static String string(HttpRequest request);
    public static String string(HttpResponse response);
    public static byte[] bytes(Contents.Supplier supplier);
    
    /**
     * Content supplier interface
     */
    public interface Supplier {
        InputStream get();
    }
}

Usage Examples:

import org.openqa.selenium.remote.http.Contents;

// Create content
Contents.Supplier jsonContent = Contents.utf8String("{\"key\":\"value\"}");
Contents.Supplier binaryContent = Contents.bytes(fileData);
Contents.Supplier emptyContent = Contents.empty();

// Set request content
HttpRequest request = new HttpRequest(HttpMethod.POST, "/data");
request.setContent(jsonContent);

// Extract response content
HttpResponse response = client.execute(request);
String responseText = Contents.string(response);
byte[] responseBytes = Contents.bytes(response.getContent());

JDK HTTP Implementation

Built-in HTTP client implementation using Java's native HTTP client.

/**
 * JDK-based HTTP client implementation
 */
public class JdkHttpClient implements HttpClient {
    
    public HttpResponse execute(HttpRequest req);
    public CompletableFuture<HttpResponse> executeAsync(HttpRequest req);
    public WebSocket openSocket(HttpRequest request, WebSocket.Listener listener);
    public void close();
}

Install with Tessl CLI

npx tessl i tessl/maven-org-seleniumhq-selenium--selenium-remote-driver

docs

capabilities-management.md

command-execution.md

distributed-tracing.md

driver-services.md

http-communication.md

index.md

webdriver-operations.md

tile.json

tessl/maven-org-seleniumhq-selenium--selenium-remote-driver