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

Capabilities Management

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

Browser capability specification and negotiation system for defining browser requirements and configuration options. This system enables precise control over browser behavior, feature support, and testing environment configuration in both local and remote WebDriver scenarios.

Capabilities

DesiredCapabilities

Mutable capabilities implementation for specifying browser requirements and configuration options.

/**
 * Mutable capabilities implementation for specifying browser requirements
 */
public class DesiredCapabilities implements MutableCapabilities {
    
    // Constructors
    public DesiredCapabilities();
    public DesiredCapabilities(String browser, String version, Platform platform);
    public DesiredCapabilities(Map<String, ?> rawMap);
    public DesiredCapabilities(Capabilities other);
    public DesiredCapabilities(Capabilities... others);
    
    // Browser configuration
    public void setBrowserName(String browserName);
    public void setVersion(String version);
    public void setPlatform(Platform platform);
    
    // Security settings
    public boolean acceptInsecureCerts();
    public void setAcceptInsecureCerts(boolean acceptInsecureCerts);
    
    // Capability merging
    public DesiredCapabilities merge(Capabilities extraCapabilities);
}

Usage Examples:

import org.openqa.selenium.remote.DesiredCapabilities;
import org.openqa.selenium.Platform;

// Basic browser specification
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setBrowserName("chrome");
capabilities.setVersion("latest");
capabilities.setPlatform(Platform.LINUX);

// Constructor with parameters
DesiredCapabilities chromeCapabilities = new DesiredCapabilities("chrome", "latest", Platform.ANY);

// Security configuration
capabilities.setAcceptInsecureCerts(true);

// From map
Map<String, Object> capMap = Map.of(
    "browserName", "firefox",
    "browserVersion", "114.0",
    "acceptInsecureCerts", true
);
DesiredCapabilities fromMap = new DesiredCapabilities(capMap);

// Merging capabilities
DesiredCapabilities baseCapabilities = new DesiredCapabilities("chrome", null, Platform.ANY);
DesiredCapabilities additionalCapabilities = new DesiredCapabilities();
additionalCapabilities.setAcceptInsecureCerts(true);
DesiredCapabilities merged = baseCapabilities.merge(additionalCapabilities);

CapabilityType Constants

Standard WebDriver capability names defined by the W3C specification.

/**
 * Constants for standard WebDriver capabilities
 */
public interface CapabilityType {
    
    // Core browser capabilities
    String BROWSER_NAME = "browserName";
    String PLATFORM_NAME = "platformName";  
    String BROWSER_VERSION = "browserVersion";
    
    // Security and behavior
    String ACCEPT_INSECURE_CERTS = "acceptInsecureCerts";
    String PAGE_LOAD_STRATEGY = "pageLoadStrategy";
    String UNHANDLED_PROMPT_BEHAVIOUR = "unhandledPromptBehavior";
    String STRICT_FILE_INTERACTABILITY = "strictFileInteractability";
    
    // Window and positioning
    String SET_WINDOW_RECT = "setWindowRect";
    
    // Network and proxy
    String PROXY = "proxy";
    
    // Timeouts
    String TIMEOUTS = "timeouts";
    
    // Selenium-specific extensions
    String ENABLE_DOWNLOADS = "se:downloadsEnabled";
}

Usage Examples:

import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.MutableCapabilities;

// Using capability constants
MutableCapabilities capabilities = new MutableCapabilities();
capabilities.setCapability(CapabilityType.BROWSER_NAME, "chrome");
capabilities.setCapability(CapabilityType.BROWSER_VERSION, "latest");
capabilities.setCapability(CapabilityType.ACCEPT_INSECURE_CERTS, true);
capabilities.setCapability(CapabilityType.PAGE_LOAD_STRATEGY, "eager");
capabilities.setCapability(CapabilityType.ENABLE_DOWNLOADS, true);

// Timeout configuration
Map<String, Object> timeouts = Map.of(
    "implicit", 10000,
    "pageLoad", 30000,
    "script", 30000
);
capabilities.setCapability(CapabilityType.TIMEOUTS, timeouts);

Browser Constants

Browser identification constants and utilities for cross-browser compatibility.

/**
 * Browser identification constants and utilities
 */
public interface Browser {
    
    // Browser constants
    Browser CHROME = create("chrome");
    Browser EDGE = create("msedge");  
    Browser HTMLUNIT = create("htmlunit");
    Browser IE = create("internet explorer");
    Browser FIREFOX = create("firefox");
    Browser OPERA = create("opera");
    Browser SAFARI = create("safari");
    Browser SAFARI_TECH_PREVIEW = create("Safari Technology Preview");
    
    // Browser identification methods
    String browserName();
    boolean is(String browserName);
    boolean is(Capabilities caps);
    String toJson();
    
    // Factory method
    static Browser create(String browserName);
}

Usage Examples:

import org.openqa.selenium.remote.Browser;
import org.openqa.selenium.Capabilities;

// Browser identification
String chromeName = Browser.CHROME.browserName(); // "chrome"
boolean isChrome = Browser.CHROME.is("chrome");   // true
boolean isFirefox = Browser.FIREFOX.is("chrome"); // false

// Check capabilities
Capabilities caps = new DesiredCapabilities("firefox", null, Platform.ANY);
boolean firefoxCaps = Browser.FIREFOX.is(caps); // true

// Custom browser
Browser customBrowser = Browser.create("my-custom-browser");

// JSON serialization
String chromeJson = Browser.CHROME.toJson(); // "chrome"

Capability Validation and Negotiation

// W3C capability validation example
public boolean isValidW3CCapability(String capabilityName) {
    // W3C standard capabilities
    Set<String> w3cStandard = Set.of(
        CapabilityType.BROWSER_NAME,
        CapabilityType.BROWSER_VERSION,
        CapabilityType.PLATFORM_NAME,
        CapabilityType.ACCEPT_INSECURE_CERTS,
        CapabilityType.PAGE_LOAD_STRATEGY,
        CapabilityType.PROXY,
        CapabilityType.SET_WINDOW_RECT,
        CapabilityType.TIMEOUTS,
        CapabilityType.STRICT_FILE_INTERACTABILITY,
        CapabilityType.UNHANDLED_PROMPT_BEHAVIOUR
    );
    
    return w3cStandard.contains(capabilityName) || 
           capabilityName.contains(":"); // Vendor-specific capabilities
}

// Capability negotiation example
public Capabilities negotiateCapabilities(Capabilities requested, Capabilities supported) {
    MutableCapabilities negotiated = new MutableCapabilities();
    
    // Browser name is required
    String requestedBrowser = (String) requested.getCapability(CapabilityType.BROWSER_NAME);
    String supportedBrowser = (String) supported.getCapability(CapabilityType.BROWSER_NAME);
    
    if (Objects.equals(requestedBrowser, supportedBrowser)) {
        negotiated.setCapability(CapabilityType.BROWSER_NAME, requestedBrowser);
    } else {
        throw new SessionNotCreatedException("Browser mismatch");
    }
    
    // Version negotiation - use supported if not specified
    String requestedVersion = (String) requested.getCapability(CapabilityType.BROWSER_VERSION);
    if (requestedVersion == null || "latest".equals(requestedVersion)) {
        negotiated.setCapability(CapabilityType.BROWSER_VERSION, 
            supported.getCapability(CapabilityType.BROWSER_VERSION));
    } else {
        negotiated.setCapability(CapabilityType.BROWSER_VERSION, requestedVersion);
    }
    
    return negotiated;
}

Advanced Capability Patterns

// Browser-specific options pattern
ChromeOptions chromeOptions = new ChromeOptions();
chromeOptions.addArguments("--headless", "--no-sandbox");
chromeOptions.setExperimentalOption("useAutomationExtension", false);

// Merge with desired capabilities
DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(ChromeOptions.CAPABILITY, chromeOptions);

// Platform-specific capabilities
if (Platform.getCurrent().is(Platform.WINDOWS)) {
    capabilities.setPlatform(Platform.WINDOWS);
    capabilities.setCapability("ms:edgeOptions", edgeOptions);
} else if (Platform.getCurrent().is(Platform.MAC)) {
    capabilities.setPlatform(Platform.MAC);
    capabilities.setCapability("safari:options", safariOptions);
}

// Grid-specific metadata
capabilities.setCapability("se:name", "My Test Session");
capabilities.setCapability("se:build", "Build 1.2.3");
capabilities.setCapability("se:tags", Arrays.asList("smoke", "regression"));

// Cloud provider capabilities
capabilities.setCapability("sauce:options", sauceOptions);
capabilities.setCapability("bstack:options", browserStackOptions);

Proxy Configuration

import org.openqa.selenium.Proxy;

// HTTP proxy configuration
Proxy proxy = new Proxy();
proxy.setHttpProxy("proxy.company.com:8080");
proxy.setSslProxy("proxy.company.com:8080");
proxy.setNoProxy("localhost,127.0.0.1");

capabilities.setCapability(CapabilityType.PROXY, proxy);

// PAC (Proxy Auto-Configuration) file
Proxy pacProxy = new Proxy();
pacProxy.setProxyAutoconfigUrl("http://company.com/proxy.pac");
capabilities.setCapability(CapabilityType.PROXY, pacProxy);

// SOCKS proxy
Proxy socksProxy = new Proxy();
socksProxy.setSocksProxy("socks.proxy.com:1080");
socksProxy.setSocksUsername("username");
socksProxy.setSocksPassword("password");
capabilities.setCapability(CapabilityType.PROXY, socksProxy);

Timeout Configuration

// Configure various timeout types
Map<String, Object> timeouts = new HashMap<>();
timeouts.put("implicit", 10000);        // 10 seconds for element finding
timeouts.put("pageLoad", 30000);        // 30 seconds for page loading
timeouts.put("script", 30000);          // 30 seconds for script execution

capabilities.setCapability(CapabilityType.TIMEOUTS, timeouts);

// Alternative using Duration objects
Map<String, Duration> durationTimeouts = Map.of(
    "implicit", Duration.ofSeconds(10),
    "pageLoad", Duration.ofSeconds(30),
    "script", Duration.ofSeconds(30)
);

Page Load Strategy Configuration

// Configure page load strategy
capabilities.setCapability(CapabilityType.PAGE_LOAD_STRATEGY, "normal");   // Wait for all resources
capabilities.setCapability(CapabilityType.PAGE_LOAD_STRATEGY, "eager");    // Wait for DOM ready
capabilities.setCapability(CapabilityType.PAGE_LOAD_STRATEGY, "none");     // Don't wait

// Unhandled prompt behavior
capabilities.setCapability(CapabilityType.UNHANDLED_PROMPT_BEHAVIOUR, "accept");
capabilities.setCapability(CapabilityType.UNHANDLED_PROMPT_BEHAVIOUR, "dismiss");
capabilities.setCapability(CapabilityType.UNHANDLED_PROMPT_BEHAVIOUR, "ignore");

Capability Debugging and Inspection

// Debug capability matching
public void debugCapabilities(Capabilities requested, Capabilities actual) {
    System.out.println("Requested capabilities:");
    requested.asMap().forEach((key, value) -> 
        System.out.println("  " + key + " = " + value));
    
    System.out.println("Actual capabilities:");
    actual.asMap().forEach((key, value) -> 
        System.out.println("  " + key + " = " + value));
    
    // Find mismatches
    requested.asMap().forEach((key, requestedValue) -> {
        Object actualValue = actual.getCapability(key);
        if (!Objects.equals(requestedValue, actualValue)) {
            System.out.println("MISMATCH: " + key + 
                " requested=" + requestedValue + 
                " actual=" + actualValue);
        }
    });
}

// Capability serialization for logging
public String serializeCapabilities(Capabilities capabilities) {
    return capabilities.asMap().entrySet().stream()
        .map(entry -> entry.getKey() + "=" + entry.getValue())
        .collect(Collectors.joining(", ", "{", "}"));
}

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