tessl/maven-org-wiremock--wiremock

WireMock is a comprehensive API mocking and service virtualization library for testing and development environments with HTTP server simulation capabilities.

Overview

Eval results

Files

Server Configuration

Name: tessl/maven-org-wiremock--wiremock
Author: tessl

Comprehensive server management functionality for starting, configuring, and controlling WireMock instances with extensive configuration options including HTTP/HTTPS ports, SSL settings, proxy configuration, and performance tuning.

Capabilities

WireMockServer Class

Main server class that manages the HTTP server lifecycle and provides administrative capabilities.

/**
 * Main WireMock server class implementing Container, Stubbing, and Admin interfaces
 */
class WireMockServer implements Container, Stubbing, Admin {
    /** Create server with custom options */
    WireMockServer(Options options);
    
    /** Create server with specific HTTP port */
    WireMockServer(int port);
    
    /** Create server with HTTP and HTTPS ports */
    WireMockServer(int port, Integer httpsPort, FileSource fileSource, 
                   boolean enableBrowserProxying, ProxySettings proxySettings, 
                   Notifier notifier);
    
    /** Start the server */
    void start();
    
    /** Stop the server gracefully */
    void stop();
    
    /** Get the HTTP port the server is running on */
    int port();
    
    /** Check if the server is currently running */
    boolean isRunning();
    
    /** Shutdown the server (alias for stop) */
    void shutdown();
}

Usage Examples:

import com.github.tomakehurst.wiremock.WireMockServer;
import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;

// Basic server on default port
WireMockServer server = new WireMockServer();
server.start();

// Server on specific port
WireMockServer server = new WireMockServer(8089);
server.start();

// Server with custom configuration
WireMockServer server = new WireMockServer(
    wireMockConfig()
        .port(8089)
        .httpsPort(8443)
        .keystorePath("keystore.jks")
        .keystorePassword("password")
);
server.start();

// Always stop server when done
server.stop();

WireMockConfiguration Class

Configuration builder providing fluent API for all server options.

/**
 * Configuration builder for WireMock server options
 */
class WireMockConfiguration implements Options {
    /** Create new configuration instance */
    static WireMockConfiguration wireMockConfig();
    
    /** Alias for wireMockConfig() */
    static WireMockConfiguration options();
    
    // Port Configuration
    /** Set HTTP port number */
    WireMockConfiguration port(int portNumber);
    
    /** Use dynamic port allocation */
    WireMockConfiguration dynamicPort();
    
    /** Set HTTPS port number */
    WireMockConfiguration httpsPort(Integer httpsPort);
    
    /** Use dynamic HTTPS port allocation */
    WireMockConfiguration dynamicHttpsPort();
    
    // Protocol Configuration
    /** Disable HTTP protocol */
    WireMockConfiguration httpDisabled(boolean httpDisabled);
    
    /** Disable HTTP/2 over plaintext */
    WireMockConfiguration http2PlainDisabled(boolean enabled);
    
    /** Disable HTTP/2 over TLS */
    WireMockConfiguration http2TlsDisabled(boolean enabled);
    
    // Server Configuration
    /** Set server bind address */
    WireMockConfiguration bindAddress(String bindAddress);
    
    /** Set container thread pool size */
    WireMockConfiguration containerThreads(Integer containerThreads);
    
    /** Set response timeout in milliseconds */
    WireMockConfiguration timeout(int timeout);
    
    // HTTPS/SSL Configuration
    /** Set keystore file path */
    WireMockConfiguration keystorePath(String path);
    
    /** Set keystore password */
    WireMockConfiguration keystorePassword(String keyStorePassword);
    
    /** Set key manager password */
    WireMockConfiguration keyManagerPassword(String keyManagerPassword);
    
    /** Set keystore type (JKS, PKCS12, etc.) */
    WireMockConfiguration keystoreType(String keyStoreType);
    
    /** Set truststore file path */
    WireMockConfiguration trustStorePath(String truststorePath);
    
    /** Set truststore password */
    WireMockConfiguration trustStorePassword(String trustStorePassword);
    
    /** Set truststore type */
    WireMockConfiguration trustStoreType(String trustStoreType);
    
    /** Require client certificate authentication */
    WireMockConfiguration needClientAuth(boolean needClientAuth);
    
    // File and Storage Configuration
    /** Set root directory for files */
    WireMockConfiguration withRootDirectory(String path);
    
    /** Set directory for response body files */
    WireMockConfiguration usingFilesUnderDirectory(String path);
    
    /** Use classpath files */
    WireMockConfiguration usingFilesUnderClasspath(String path);
    
    /** Set custom file source */
    WireMockConfiguration fileSource(FileSource fileSource);
    
    /** Set custom mappings source */
    WireMockConfiguration mappingSource(MappingsSource mappingsSource);
    
    /** Set filename template for generated files */
    WireMockConfiguration filenameTemplate(String filenameTemplate);
    
    // Jetty Server Configuration
    /** Set number of Jetty acceptor threads */
    WireMockConfiguration jettyAcceptors(Integer jettyAcceptors);
    
    /** Set Jetty accept queue size */
    WireMockConfiguration jettyAcceptQueueSize(Integer jettyAcceptQueueSize);
    
    /** Set maximum request header size */
    WireMockConfiguration jettyHeaderRequestSize(Integer jettyHeaderRequestSize);
    
    /** Set maximum response header size */
    WireMockConfiguration jettyHeaderResponseSize(Integer jettyHeaderResponseSize);
    
    /** Set Jetty stop timeout */
    WireMockConfiguration jettyStopTimeout(Long jettyStopTimeout);
    
    /** Set Jetty idle timeout */
    WireMockConfiguration jettyIdleTimeout(Long jettyIdleTimeout);
    
    // Performance Configuration
    /** Enable asynchronous response processing */
    WireMockConfiguration asynchronousResponseEnabled(boolean asynchronousResponseEnabled);
    
    /** Set number of asynchronous response threads */
    WireMockConfiguration asynchronousResponseThreads(int asynchronousResponseThreads);
    
    /** Set maximum HTTP client connections */
    WireMockConfiguration maxHttpClientConnections(int maxHttpClientConnections);
    
    /** Disable HTTP connection reuse */
    WireMockConfiguration disableConnectionReuse(boolean disableConnectionReuse);
    
    /** Set webhook thread pool size */
    WireMockConfiguration withWebhookThreadPoolSize(Integer webhookThreadPoolSize);
    
    // Response Configuration
    /** Set chunked transfer encoding policy */
    WireMockConfiguration useChunkedTransferEncoding(ChunkedEncodingPolicy policy);
    
    /** Disable gzip compression */
    WireMockConfiguration gzipDisabled(boolean gzipDisabled);
    
    /** Disable stub request logging */
    WireMockConfiguration stubRequestLoggingDisabled(boolean disabled);
    
    /** Enable CORS for stub responses */
    WireMockConfiguration stubCorsEnabled(boolean enabled);
    
    /** Set maximum logged response size */
    WireMockConfiguration maxLoggedResponseSize(int maxSize);
}

Usage Examples:

import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;

// Basic HTTP server
WireMockConfiguration config = wireMockConfig()
    .port(8089)
    .bindAddress("localhost");

// HTTPS enabled server
WireMockConfiguration httpsConfig = wireMockConfig()
    .port(8089)
    .httpsPort(8443)
    .keystorePath("/path/to/keystore.jks")
    .keystorePassword("secret")
    .keystoreType("JKS");

// Performance optimized server
WireMockConfiguration perfConfig = wireMockConfig()
    .port(8089)
    .containerThreads(50)
    .asynchronousResponseEnabled(true)
    .asynchronousResponseThreads(10)
    .maxHttpClientConnections(100)
    .jettyAcceptors(4)
    .jettyAcceptQueueSize(500);

// File-based configuration
WireMockConfiguration fileConfig = wireMockConfig()
    .port(8089)
    .usingFilesUnderDirectory("/path/to/wiremock")
    .filenameTemplate("{{request.url}}-{{request.method}}");

Options Interface

Core configuration interface implemented by WireMockConfiguration with all available options.

/**
 * Main configuration interface with all WireMock options
 */
interface Options {
    // Constants
    int DEFAULT_PORT = 8080;
    int DYNAMIC_PORT = 0;
    int DEFAULT_TIMEOUT = 300_000;
    int DEFAULT_CONTAINER_THREADS = 25;
    String DEFAULT_BIND_ADDRESS = "0.0.0.0";
    
    // Core Configuration
    int portNumber();
    String bindAddress();
    int containerThreads();
    long timeout();
    
    // Protocol Configuration
    boolean getHttpDisabled();
    boolean getHttp2PlainDisabled();
    boolean getHttp2TlsDisabled();
    HttpsSettings httpsSettings();
    JettySettings jettySettings();
    
    // Storage and File Configuration
    FileSource filesRoot();
    MappingsLoader mappingsLoader();
    MappingsSaver mappingsSaver();
    FilenameMaker getFilenameMaker();
    
    // Request Journal Configuration
    boolean requestJournalDisabled();
    Optional<Integer> maxRequestJournalEntries();
    List<CaseInsensitiveKey> matchingHeaders();
    
    // Extension Configuration
    ExtensionDeclarations getDeclaredExtensions();
    boolean isExtensionScanningEnabled();
    
    // Factory Configuration
    HttpServerFactory httpServerFactory();
    HttpClientFactory httpClientFactory();
    ThreadPoolFactory threadPoolFactory();
    
    // Security Configuration
    Authenticator getAdminAuthenticator();
    boolean getHttpsRequiredForAdminApi();
    
    // Performance Configuration
    AsynchronousResponseSettings getAsynchronousResponseSettings();
    ChunkedEncodingPolicy getChunkedEncodingPolicy();
    int getMaxHttpClientConnections();
    boolean getDisableConnectionReuse();
    int getWebhookThreadPoolSize();
    
    // Response Configuration
    boolean getGzipDisabled();
    boolean getStubRequestLoggingDisabled();
    boolean getStubCorsEnabled();
    DataTruncationSettings getDataTruncationSettings();
    
    // Template Configuration
    boolean getResponseTemplatingEnabled();
    boolean getResponseTemplatingGlobal();
    Long getMaxTemplateCacheEntries();
    Set<String> getTemplatePermittedSystemKeys();
    boolean getTemplateEscapingDisabled();
    
    // Notification
    Notifier notifier();
}

enum ChunkedEncodingPolicy {
    ALWAYS, NEVER, BODY_FILE
}

Configuration Support Types

class HttpsSettings {
    String keystorePath();
    String keystorePassword();
    String keyManagerPassword();
    String keystoreType();
    String trustStorePath();
    String trustStorePassword();
    String trustStoreType();
    boolean needClientAuth();
}

class JettySettings {
    Integer getAcceptors();
    Integer getAcceptQueueSize();
    Integer getRequestHeaderSize();
    Integer getResponseHeaderSize();
    Long getStopTimeout();
    Long getIdleTimeout();
}

class AsynchronousResponseSettings {
    boolean isEnabled();
    int getThreads();
}

class DataTruncationSettings {
    int getMaxLoggedResponseSize();
}

interface Notifier {
    void info(String message);
    void error(String message);
    void error(String message, Throwable t);
}

interface FileSource {
    BinaryFile getBinaryFileNamed(String name);
    TextFile getTextFileNamed(String name);
    void createIfNecessary();
    FileSource child(String subDirectoryName);
    String getPath();
    List<TextFile> listFilesRecursively();
}

Install with Tessl CLI

npx tessl i tessl/maven-org-wiremock--wiremock

docs

command-line-interface.md

request-verification.md

response-building.md

server-configuration.md

tile.json

tessl/maven-org-wiremock--wiremock