Extension Management

/**
 * Interface for managing browser extensions.
 * Implemented by FirefoxDriver to provide extension management capabilities.
 */
@Beta
public interface HasExtensions {
    
    /**
     * Installs a browser extension from a file path.
     * @param path Path to extension file (.xpi) or directory
     * @return Extension ID string for later reference
     */
    String installExtension(Path path);
    
    /**
     * Installs a browser extension with temporary flag option.
     * @param path Path to extension file (.xpi) or directory
     * @param temporary true for temporary installation, false for permanent
     * @return Extension ID string for later reference
     */
    String installExtension(Path path, Boolean temporary);
    
    /**
     * Uninstalls a previously installed extension.
     * @param extensionId Extension ID returned from installExtension
     */
    void uninstallExtension(String extensionId);
}

import org.openqa.selenium.firefox.FirefoxDriver;
import org.openqa.selenium.firefox.HasExtensions;
import java.nio.file.Paths;

FirefoxDriver driver = new FirefoxDriver();
HasExtensions extensionManager = driver;  // FirefoxDriver implements HasExtensions

// Install permanent extension
String extensionId = extensionManager.installExtension(
    Paths.get("/path/to/extension.xpi")
);

// Install temporary extension (removed when browser closes)
String tempExtensionId = extensionManager.installExtension(
    Paths.get("/path/to/temp-extension.xpi"), 
    true  // temporary
);

// Uninstall extension
extensionManager.uninstallExtension(extensionId);

/**
 * Interface for Firefox extensions from various sources.
 * Provides unified API for extension installation.
 */
public interface Extension {
    
    /**
     * Writes the extension to the specified parent directory.
     * @param parentDirectory Directory where extension should be written
     */
    void writeTo(File parentDirectory);
}

/**
 * Extension loaded from file system.
 * Supports both .xpi files and unpacked extension directories.
 */
public class FileExtension implements Extension {
    
    /**
     * Creates a FileExtension from a file or directory.
     * @param toInstall Extension file (.xpi) or directory to install
     */
    public FileExtension(File toInstall);
    
    /**
     * Writes the extension to the specified parent directory.
     * @param parentDirectory Directory where extension should be written
     */
    @Override
    public void writeTo(File parentDirectory);
}

import org.openqa.selenium.firefox.FileExtension;
import java.io.File;

// Create extension from .xpi file
File xpiFile = new File("/path/to/extension.xpi");
FileExtension extension = new FileExtension(xpiFile);

// Create extension from directory
File extensionDir = new File("/path/to/unpacked-extension");
FileExtension extension = new FileExtension(extensionDir);

// Write extension to profile directory
File profileDir = new File("/tmp/firefox-profile");
extension.writeTo(profileDir);

/**
 * Extension loaded from classpath resources.
 * Useful for bundling extensions with test applications.
 */
public class ClasspathExtension implements Extension {
    
    /**
     * Creates a ClasspathExtension from classpath resources.
     * @param loadResourcesUsing Class to use for resource loading context
     * @param loadFrom Classpath location of extension resources
     */
    public ClasspathExtension(Class<?> loadResourcesUsing, String loadFrom);
    
    /**
     * Writes the extension to the specified parent directory.
     * @param parentDirectory Directory where extension should be written
     */
    @Override
    public void writeTo(File parentDirectory);
}

import org.openqa.selenium.firefox.ClasspathExtension;

// Load extension from classpath
ClasspathExtension extension = new ClasspathExtension(
    MyTestClass.class,  // Class for resource context
    "/extensions/my-test-extension"  // Classpath location
);

// Write to profile directory
File profileDir = new File("/tmp/firefox-profile");
extension.writeTo(profileDir);

// From FirefoxProfile class
/**
 * Adds an extension from the classpath to the profile.
 * @param loadResourcesUsing Class to use for resource loading
 * @param loadFrom Classpath location of extension
 */
public void addExtension(Class<?> loadResourcesUsing, String loadFrom);

/**
 * Adds an extension from a file to the profile.
 * @param extensionToInstall Extension file (.xpi) or directory
 */
public void addExtension(File extensionToInstall);

/**
 * Adds an extension with a specific key to the profile.
 * @param key Extension identifier key
 * @param extension Extension implementation
 */
public void addExtension(String key, Extension extension);

import org.openqa.selenium.firefox.*;
import java.io.File;
import java.nio.file.Paths;

// Method 1: Runtime extension management
FirefoxDriver driver = new FirefoxDriver();

// Install extension at runtime
String extensionId = driver.installExtension(
    Paths.get("/path/to/extension.xpi")
);
System.out.println("Installed extension with ID: " + extensionId);

// Install temporary extension
String tempId = driver.installExtension(
    Paths.get("/path/to/dev-extension"), 
    true  // temporary
);

// Use the browser with extensions
driver.get("https://example.com");
// ... test operations that use extension functionality

// Remove extension when done
driver.uninstallExtension(extensionId);

// Method 2: Profile-based extension management
FirefoxProfile profile = new FirefoxProfile();

// Add extension from file
File extensionFile = new File("/path/to/extension.xpi");
profile.addExtension(extensionFile);

// Add extension from classpath
profile.addExtension(MyTestClass.class, "/test-extensions/helper-extension");

// Add custom extension implementation
Extension customExtension = new FileExtension(new File("/path/to/custom.xpi"));
profile.addExtension("custom-key", customExtension);

// Use profile with driver
FirefoxOptions options = new FirefoxOptions().setProfile(profile);
WebDriver driver2 = new FirefoxDriver(options);
// Extensions are automatically available

// Method 3: Mixed approach
FirefoxProfile profile = new FirefoxProfile();
// Add persistent extensions to profile
profile.addExtension(new File("/path/to/persistent-extension.xpi"));

FirefoxOptions options = new FirefoxOptions().setProfile(profile);
FirefoxDriver driver3 = new FirefoxDriver(options);

// Add temporary extension at runtime
String runtimeId = driver3.installExtension(
    Paths.get("/path/to/temporary-extension.xpi"),
    true
);

// Now browser has both persistent and temporary extensions

// For development workflow with unpacked extensions
File devExtensionDir = new File("/workspace/my-extension/src");
String devExtensionId = driver.installExtension(
    devExtensionDir.toPath(),
    true  // temporary for development
);

// Test extension functionality
driver.get("https://test-site.com");
// ... test extension behavior

// Reload extension after changes
driver.uninstallExtension(devExtensionId);
String newId = driver.installExtension(devExtensionDir.toPath(), true);

// Package extension for distribution
File packagedExtension = new File("/workspace/my-extension/dist/extension.xpi");
String prodId = driver.installExtension(packagedExtension.toPath(), false);