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

Extension System

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

Plugin architecture for extending WireMock functionality with custom transformers, filters, event listeners, and administrative capabilities. Supports both programmatic and declarative extension registration.

Capabilities

Core Extension Infrastructure

Base extension interface and lifecycle management for all WireMock extensions.

/**
 * Base interface for all WireMock extensions
 */
interface Extension {
    /** Get unique extension name */
    String getName();
    
    /** Called when extension is loaded and server starts */
    default void start() {}
    
    /** Called when server stops */
    default void stop() {}
}

/**
 * Parameter container for extension configuration
 */
class Parameters extends Metadata {
    /** Get parameter value by key */
    <T> T get(String key);
    
    /** Get parameter value with default */
    <T> T get(String key, T defaultValue);
    
    /** Check if parameter exists */
    boolean containsKey(String key);
    
    /** Get all parameter keys */
    Set<String> keySet();
    
    /** Check if parameters are empty */
    boolean isEmpty();
}

Response Transformation Extensions

Modern response transformation capabilities with access to request context and serve events.

/**
 * Modern interface for transforming HTTP responses
 */
interface ResponseTransformerV2 extends Extension {
    /** Transform response with full context */
    Response transform(Response response, ServeEvent serveEvent);
    
    /** Check if transformer applies to this request */
    default boolean applyGlobally() {
        return false;
    }
}

/**
 * Interface for transforming response definitions before serving
 */
interface ResponseDefinitionTransformerV2 extends Extension {
    /** Transform response definition */
    ResponseDefinition transform(ResponseDefinition responseDefinition, 
                                Request request, Parameters parameters);
    
    /** Get transformer name */
    String getName();
    
    /** Check if transformer applies globally */
    default boolean applyGlobally() {
        return false;
    }
}

/**
 * Abstract base class for response transformers
 */
abstract class AbstractTransformer implements ResponseDefinitionTransformerV2 {
    /** Constructor with transformer name */
    protected AbstractTransformer(String name);
    
    /** Constructor with global application flag */
    protected AbstractTransformer(String name, boolean applyGlobally);
    
    String getName();
    boolean applyGlobally();
}

/**
 * Base class for stub mapping transformations during recording
 */
abstract class StubMappingTransformer {
    /** Transform stub mapping */
    abstract StubMapping transform(StubMapping stubMapping, 
                                  FileSource files, Parameters parameters);
    
    /** Get transformer name */
    abstract String getName();
}

Usage Examples:

// Custom response transformer
public class TimestampTransformer implements ResponseTransformerV2 {
    @Override
    public String getName() {
        return "timestamp-transformer";
    }
    
    @Override
    public Response transform(Response response, ServeEvent serveEvent) {
        String originalBody = response.getBodyAsString();
        String timestampedBody = originalBody.replace(
            "{{timestamp}}", 
            Instant.now().toString()
        );
        
        return Response.Builder.like(response)
            .but()
            .body(timestampedBody)
            .build();
    }
}

// Register transformer
wireMock.stubFor(get(urlEqualTo("/api/time"))
    .willReturn(aResponse()
        .withBody("Current time: {{timestamp}}")
        .withTransformers("timestamp-transformer")));

Request Filtering Extensions

Modern request filtering system for intercepting and modifying requests before they reach stub matching.

/**
 * Modern interface for filtering incoming requests
 */
interface RequestFilterV2 extends Extension {
    /** Filter request and return action */
    RequestFilterAction filter(Request request, Parameters parameters);
}

/**
 * V2 filter specifically for stub requests
 */
interface StubRequestFilterV2 extends RequestFilterV2 {
    // Inherits filter method from RequestFilterV2
}

/**
 * V2 filter for admin API requests
 */
interface AdminRequestFilterV2 extends RequestFilterV2 {
    // Inherits filter method from RequestFilterV2
}

/**
 * Action class for filter responses
 */
class RequestFilterAction {
    /** Continue processing request */
    static RequestFilterAction continueWith(Request request);
    
    /** Stop processing and return response */
    static RequestFilterAction stopWith(ResponseDefinition responseDefinition);
    
    /** Check if processing should continue */
    boolean isContinue();
    
    /** Check if processing should stop */
    boolean isStop();
    
    /** Get the request (possibly modified) */
    Request getRequest();
    
    /** Get the response definition to return */
    ResponseDefinition getResponseDefinition();
}

Usage Examples:

// Custom request filter
public class AuthFilter implements StubRequestFilterV2 {
    @Override
    public String getName() {
        return "auth-filter";
    }
    
    @Override
    public RequestFilterAction filter(Request request, Parameters parameters) {
        String authHeader = request.getHeader("Authorization");
        
        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            return RequestFilterAction.stopWith(
                aResponse()
                    .withStatus(401)
                    .withBody("Unauthorized")
                    .build()
            );
        }
        
        return RequestFilterAction.continueWith(request);
    }
}

// Register filter in configuration
WireMockServer server = new WireMockServer(
    wireMockConfig()
        .extensions("com.example.AuthFilter")
);

Event Listening Extensions

Modern event listener system for monitoring request lifecycle and stub management events.

/**
 * Modern interface for listening to request lifecycle events
 */
interface ServeEventListener extends Extension {
    /** Called before request matching */
    default void beforeMatch(ServeEvent serveEvent, Parameters parameters) {}
    
    /** Called after request matching */
    default void afterMatch(ServeEvent serveEvent, Parameters parameters) {}
    
    /** Called before response is sent */
    default void beforeResponseSent(ServeEvent serveEvent, Parameters parameters) {}
    
    /** Called after request processing is complete */
    default void afterComplete(ServeEvent serveEvent, Parameters parameters) {}
}

/**
 * Interface for listening to stub mapping lifecycle events
 */
interface StubLifecycleListener extends Extension {
    /** Called when stub mapping is created */
    default void onStubMappingAdded(StubMapping stubMapping) {}
    
    /** Called when stub mapping is updated */
    default void onStubMappingUpdated(StubMapping oldStubMapping, StubMapping newStubMapping) {}
    
    /** Called when stub mapping is removed */
    default void onStubMappingRemoved(StubMapping stubMapping) {}
    
    /** Called when all stubs are reset */
    default void onStubMappingsReset() {}
}

Usage Examples:

// Request monitoring listener
public class RequestMonitor implements ServeEventListener {
    @Override
    public String getName() {
        return "request-monitor";
    }
    
    @Override
    public void beforeMatch(ServeEvent serveEvent, Parameters parameters) {
        LoggedRequest request = serveEvent.getRequest();
        System.out.println("Incoming request: " + request.getMethod() + " " + request.getUrl());
    }
    
    @Override
    public void afterComplete(ServeEvent serveEvent, Parameters parameters) {
        System.out.println("Request completed in " + 
            serveEvent.getTiming().getTotalTime() + "ms");
    }
}

// Stub change listener
public class StubChangeLogger implements StubLifecycleListener {
    @Override
    public String getName() {
        return "stub-change-logger";
    }
    
    @Override
    public void onStubMappingAdded(StubMapping stubMapping) {
        System.out.println("Added stub: " + stubMapping.getName());
    }
    
    @Override
    public void onStubMappingRemoved(StubMapping stubMapping) {
        System.out.println("Removed stub: " + stubMapping.getName());
    }
}

Template System Extensions

Extensions for providing custom Handlebars helpers and template model data.

/**
 * Interface for providing custom Handlebars template helpers
 */
interface TemplateHelperProviderExtension extends Extension {
    /** Get map of helper name to helper instance */
    Map<String, Helper<?>> provideTemplateHelpers();
}

/**
 * Interface for providing additional template model data
 */
interface TemplateModelDataProviderExtension extends Extension {
    /** Get additional model data for template rendering */
    Map<String, Object> provideTemplateModelData(ServeEvent serveEvent);
}

/**
 * Main response templating transformer implementation
 */
class ResponseTemplateTransformer extends AbstractTransformer {
    /** Constructor with global application */
    ResponseTemplateTransformer(boolean global);
    
    /** Constructor with global and permitted system keys */
    ResponseTemplateTransformer(boolean global, String... permittedSystemKeys);
}

Usage Examples:

// Custom template helper
public class CustomHelpers implements TemplateHelperProviderExtension {
    @Override
    public String getName() {
        return "custom-helpers";
    }
    
    @Override
    public Map<String, Helper<?>> provideTemplateHelpers() {
        return Map.of(
            "uppercase", (Helper<String>) (context, options) -> 
                context != null ? context.toString().toUpperCase() : "",
            "randomId", (Helper<Object>) (context, options) -> 
                UUID.randomUUID().toString()
        );
    }
}

// Use custom helpers in templates
stubFor(get(urlEqualTo("/api/user"))
    .willReturn(aResponse()
        .withBody("User: {{uppercase request.headers.X-User-Name}}, ID: {{randomId}}")
        .withTransformers("response-template")));

Admin API Extensions

Extensions for adding custom administrative endpoints and mappings loaders.

/**
 * Interface for extending the admin API with custom routes
 */
interface AdminApiExtension extends Extension {
    /** Contribute additional admin routes */
    void contributeAdminApiRoutes(AdminRoutes adminRoutes);
}

/**
 * Interface for custom stub mapping loaders
 */
interface MappingsLoaderExtension extends Extension {
    /** Load mappings from custom source */
    void loadMappingsInto(StubMappings stubMappings);
}

Extension Configuration and Registration

Configuration and registration mechanisms for extensions.

/**
 * Extension declarations for configuration
 */
class ExtensionDeclarations {
    /** Get declared extensions */
    Map<String, ExtensionDeclaration> getExtensions();
    
    /** Get extension by name */
    ExtensionDeclaration getExtension(String name);
    
    /** Check if extension is declared */
    boolean hasExtension(String name);
}

class ExtensionDeclaration {
    String getName();
    String getClassName();
    Map<String, Object> getParameters();
}

/**
 * Extension factory interface
 */
interface ExtensionFactory {
    /** Create extension instance */
    Extension create();
}

Usage Examples:

// Programmatic extension registration
WireMockServer server = new WireMockServer(
    wireMockConfig()
        .extensions(
            new TimestampTransformer(),
            new AuthFilter(),
            new RequestMonitor()
        )
        .extensionScanningEnabled(true)
);

// Class-based registration
WireMockServer server = new WireMockServer(
    wireMockConfig()
        .extensions(
            "com.example.TimestampTransformer",
            "com.example.AuthFilter"
        )
);

// Factory-based registration
WireMockServer server = new WireMockServer(
    wireMockConfig()
        .extensionFactories(
            () -> new TimestampTransformer(),
            CustomExtensionFactory.class
        )
);

Legacy Extension Interfaces

/**
 * @deprecated Use ResponseTransformerV2 instead
 */
@Deprecated
interface ResponseTransformer extends Extension {
    Response transform(Request request, Response response, 
                      FileSource files, Parameters parameters);
}

/**
 * @deprecated Use ServeEventListener instead
 */
@Deprecated
interface PostServeAction extends Extension {
    void doAction(ServeEvent serveEvent, Parameters parameters);
}

/**
 * @deprecated Use RequestFilterV2 instead
 */
@Deprecated
interface RequestFilter extends Extension {
    RequestWrapper filter(RequestWrapper request);
}

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