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

Request Verification

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

Request verification system with count matching, pattern matching, and detailed error reporting for test assertions. Provides comprehensive tools for validating that expected HTTP requests were made during testing.

Capabilities

Basic Request Verification

Core verification methods for asserting that requests were made with specific patterns.

/**
 * Basic request verification methods in WireMock class
 */
// Simple Verification
/** Verify request was made exactly once */
static void verify(RequestPatternBuilder requestPatternBuilder);

/** Verify request was made specific number of times */
static void verify(int count, RequestPatternBuilder requestPatternBuilder);

/** Verify request with count matching strategy */
static void verify(CountMatchingStrategy strategy, RequestPatternBuilder pattern);

// Request Pattern Builders
/** Create request pattern for GET method */
static RequestPatternBuilder getRequestedFor(UrlPattern urlPattern);

/** Create request pattern for POST method */
static RequestPatternBuilder postRequestedFor(UrlPattern urlPattern);

/** Create request pattern for PUT method */
static RequestPatternBuilder putRequestedFor(UrlPattern urlPattern);

/** Create request pattern for DELETE method */
static RequestPatternBuilder deleteRequestedFor(UrlPattern urlPattern);

/** Create request pattern for PATCH method */
static RequestPatternBuilder patchRequestedFor(UrlPattern urlPattern);

/** Create request pattern for HEAD method */
static RequestPatternBuilder headRequestedFor(UrlPattern urlPattern);

/** Create request pattern for OPTIONS method */
static RequestPatternBuilder optionsRequestedFor(UrlPattern urlPattern);

/** Create request pattern for any method */
static RequestPatternBuilder anyRequestedFor(UrlPattern urlPattern);

Usage Examples:

// Basic verification
verify(getRequestedFor(urlEqualTo("/api/users")));

// Verify specific count
verify(3, postRequestedFor(urlEqualTo("/api/orders")));

// Verify with matching strategy
verify(moreThan(5), getRequestedFor(urlMatching("/api/products/.*")));

// Complex request verification
verify(postRequestedFor(urlEqualTo("/api/users"))
    .withHeader("Content-Type", equalTo("application/json"))
    .withRequestBody(matchingJsonPath("$.name")));

Count Matching Strategies

Flexible count matching with relational operators for sophisticated verification scenarios.

/**
 * Count matching strategy factory methods
 */
// Relational Count Matching
/** Less than expected count */
static CountMatchingStrategy lessThan(int expected);

/** Less than or equal to expected count */
static CountMatchingStrategy lessThanOrExactly(int expected);

/** Exactly expected count */
static CountMatchingStrategy exactly(int expected);

/** Greater than or equal to expected count */
static CountMatchingStrategy moreThanOrExactly(int expected);

/** Greater than expected count */
static CountMatchingStrategy moreThan(int expected);

class CountMatchingStrategy {
    /** Create strategy with mode and expected count */
    CountMatchingStrategy(CountMatchingMode mode, int expected);
    
    /** Test if actual count matches expectation */
    boolean match(int actual);
    
    int getExpected();
    CountMatchingMode getMode();
}

enum CountMatchingMode implements BiPredicate<Integer, Integer> {
    LESS_THAN,
    LESS_THAN_OR_EQUAL,
    EQUAL_TO,
    GREATER_THAN_OR_EQUAL,
    GREATER_THAN;
    
    /** Get human-readable name */
    String getFriendlyName();
    
    /** Test condition against actual and expected values */
    boolean test(Integer actual, Integer expected);
}

Usage Examples:

// Count-based verification
verify(exactly(1), getRequestedFor(urlEqualTo("/api/login")));
verify(lessThan(3), getRequestedFor(urlEqualTo("/api/retry")));
verify(moreThanOrExactly(5), getRequestedFor(urlMatching("/api/metrics/.*")));

// Custom count matching
CountMatchingStrategy customStrategy = new CountMatchingStrategy(
    CountMatchingMode.GREATER_THAN, 10);
verify(customStrategy, getRequestedFor(urlEqualTo("/api/popular")));

Request Inspection and Discovery

Methods for inspecting actual requests made and finding unmatched requests.

/**
 * Request inspection methods
 */
// Request Discovery
/** Find all requests matching pattern */
static List<LoggedRequest> findAll(RequestPatternBuilder requestPatternBuilder);

/** Get all serve events (requests and responses) */
static List<ServeEvent> getAllServeEvents();

/** Find all unmatched requests */
static List<LoggedRequest> findUnmatchedRequests();

// Near Miss Analysis  
/** Find near misses for all unmatched requests */
static List<NearMiss> findNearMissesForAllUnmatched();

/** Find near misses for specific request */
static List<NearMiss> findNearMissesFor(LoggedRequest loggedRequest);

/** Find near misses for request pattern */
static List<NearMiss> findNearMissesFor(RequestPattern requestPattern);

// Administrative Access
/** Get verification result for pattern */
static VerificationResult findRequestsMatching(RequestPattern requestPattern);

/** Count requests matching pattern */
static VerificationResult countRequestsMatching(RequestPattern requestPattern);

Usage Examples:

// Inspect actual requests
List<LoggedRequest> userRequests = findAll(
    getRequestedFor(urlMatching("/api/users/.*")));

for (LoggedRequest request : userRequests) {
    System.out.println("Request: " + request.getMethod() + " " + request.getUrl());
    System.out.println("Headers: " + request.getHeaders());
    System.out.println("Body: " + request.getBodyAsString());
}

// Find problematic requests
List<LoggedRequest> unmatched = findUnmatchedRequests();
if (!unmatched.isEmpty()) {
    List<NearMiss> nearMisses = findNearMissesForAllUnmatched();
    for (NearMiss nearMiss : nearMisses) {
        System.out.println("Near miss: " + nearMiss.getRequest().getUrl());
        System.out.println("Diff: " + nearMiss.getDiff());
    }
}

RequestPatternBuilder Class

Builder for creating detailed request patterns for verification.

/**
 * Builder for request patterns used in verification
 */
class RequestPatternBuilder {
    // Static Factory Methods
    /** Create new request pattern builder */
    static RequestPatternBuilder newRequestPattern();
    
    /** Create pattern matching all requests */
    static RequestPatternBuilder allRequests();
    
    /** Create pattern based on existing request pattern */
    static RequestPatternBuilder like(RequestPattern requestPattern);
    
    // HTTP Method and URL
    /** Set HTTP method */
    RequestPatternBuilder withMethod(RequestMethod method);
    
    /** Set URL pattern */
    RequestPatternBuilder withUrl(UrlPattern urlPattern);
    
    // Request Matching (same as MappingBuilder)
    RequestPatternBuilder withScheme(String scheme);
    RequestPatternBuilder withHost(StringValuePattern hostPattern);
    RequestPatternBuilder withPort(int port);
    RequestPatternBuilder withHeader(String key, StringValuePattern pattern);
    RequestPatternBuilder withQueryParam(String key, StringValuePattern pattern);
    RequestPatternBuilder withFormParam(String key, StringValuePattern pattern);
    RequestPatternBuilder withRequestBody(ContentPattern<?> bodyPattern);
    RequestPatternBuilder withBasicAuth(String username, String password);
    RequestPatternBuilder withCookie(String name, StringValuePattern pattern);
    
    // Custom Matching
    RequestPatternBuilder andMatching(ValueMatcher<Request> requestMatcher);
    RequestPatternBuilder andMatching(String customMatcherName);
    
    /** Build final request pattern */
    RequestPattern build();
}

Usage Examples:

// Custom request pattern building
RequestPattern complexPattern = newRequestPattern()
    .withMethod(RequestMethod.POST)
    .withUrl(urlMatching("/api/orders/[0-9]+/items"))
    .withHeader("Authorization", matching("Bearer .*"))
    .withHeader("Content-Type", equalTo("application/json"))
    .withRequestBody(matchingJsonPath("$.quantity", matching("[1-9][0-9]*")))
    .withQueryParam("expand", containing("details"))
    .build();

verify(exactly(1), complexPattern);

Request and Response Models

Data models representing captured HTTP requests and responses.

/**
 * Request and response data models
 */
class LoggedRequest {
    /** Get request URL */
    String getUrl();
    
    /** Get absolute request URL */
    String getAbsoluteUrl();
    
    /** Get HTTP method */
    RequestMethod getMethod();
    
    /** Get client IP address */
    String getClientIp();
    
    /** Get request headers */
    HttpHeaders getHeaders();
    
    /** Get query parameters */
    Map<String, QueryParameter> getQueryParams();
    
    /** Get form parameters */
    Map<String, FormParameter> getFormParams();
    
    /** Get request body as string */
    String getBodyAsString();
    
    /** Get request body as byte array */
    byte[] getBody();
    
    /** Get multipart parts */
    Collection<Request.Part> getParts();
    
    /** Get cookies */
    Map<String, Cookie> getCookies();
    
    /** Get timestamp when request was logged */
    Date getLoggedDate();
    
    /** Check if request was matched by any stub */
    boolean wasMatched();
    
    /** Get matching stub mapping */
    StubMapping getStubMapping();
}

class ServeEvent {
    /** Get event ID */
    UUID getId();
    
    /** Get logged request */
    LoggedRequest getRequest();
    
    /** Get response definition */
    ResponseDefinition getResponseDefinition();
    
    /** Get actual response sent */
    Response getResponse();
    
    /** Check if request was matched */
    boolean getWasMatched();
    
    /** Get timing information */
    Timing getTiming();
    
    /** Get post-serve actions */
    List<PostServeActionDefinition> getPostServeActions();
}

class NearMiss {
    /** Get the request that nearly matched */
    LoggedRequest getRequest();
    
    /** Get the stub mapping that nearly matched */
    StubMapping getStubMapping();
    
    /** Get detailed difference information */
    Diff getDiff();
    
    /** Get match distance (0.0 = perfect match, 1.0 = no match) */
    double getDistance();
}

Verification Exception Handling

Exception types for verification failures with detailed diagnostic information.

/**
 * Verification exception with detailed error information
 */
class VerificationException extends RuntimeException {
    /** Basic constructor with message */
    VerificationException(String message);
    
    // Static Factory Methods
    /** Create exception for unmatched request pattern */
    static VerificationException forUnmatchedRequestPattern(Diff diff);
    
    /** Create exception for single unmatched request */
    static VerificationException forSingleUnmatchedRequest(Diff diff);
    
    /** Create exception with near miss information */
    static VerificationException forUnmatchedNearMisses(List<NearMiss> nearMisses);
    
    /** Create exception for multiple unmatched requests */
    static VerificationException forUnmatchedRequests(List<LoggedRequest> requests);
}

class Diff {
    /** Get difference description */
    String toString();
    
    /** Get actual request information */
    LoggedRequest getActualRequest();
    
    /** Get expected pattern information */
    RequestPattern getExpectedPattern();
}

Usage Examples:

try {
    verify(exactly(1), getRequestedFor(urlEqualTo("/api/critical")));
} catch (VerificationException e) {
    System.err.println("Verification failed: " + e.getMessage());
    
    // Get diagnostic information
    List<LoggedRequest> unmatched = findUnmatchedRequests();
    List<NearMiss> nearMisses = findNearMissesForAllUnmatched();
    
    // Log details for debugging
    System.err.println("Unmatched requests: " + unmatched.size());
    for (NearMiss nearMiss : nearMisses) {
        System.err.println("Near miss: " + nearMiss.getDiff());
    }
}

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