mock-server/mockserver-monorepo

Features

• API Mocking Services - Provides a multi-protocol API mocking service for HTTP, gRPC, and WebSocket interfaces.
• API Simulation and Mocking - Simulates HTTP, gRPC, and WebSocket services to replace external dependencies during development and testing.
• API Mocking Servers - Provides a multi-protocol mock server for simulating HTTP, gRPC, and WebSocket services.
• MCP Session Handshakes - Generates mock expectations for JSON-RPC 2.0 servers to handle MCP initialization and tool discovery.
• Agent Discovery - Mocks JSON-RPC 2.0 agent discovery documents and task management interactions.
• Multi-turn Interaction Managers - Scripts multi-turn interactions and tool-call sequences by matching against parsed message history.
• AI Agent Servers - Simulates AI agent servers that handle JSON-RPC tasks via SSE streaming and serve agent-card documents.
• Agent Server Simulations - Generates expectations to simulate Model Context Protocol or Agent-to-Agent server behaviors.
• AI Provider Simulators - Simulates AI providers with semantic control over text, tool calls, and usage metadata.
• Conversational State Managers - Tracks state across sequential requests to mimic multi-turn conversational flows and isolate concurrent sessions.
• LLM Provider Simulation - Mocks AI chat APIs and language model completions to test AI agents and multi-turn conversations.
• MCP Servers - Simulates Model Context Protocol servers using JSON-RPC 2.0 to expose tools and resources to LLMs.
• Provider-Agnostic Model Interfaces - Creates mock expectations for completions and embeddings that work across different AI provider schemas.
• Proxy Traffic Captures - Captures proxied HTTP requests from real services and saves them as JSON or DSL expectations.
• Chaos Engineering Frameworks - Injects network faults and latency to test how applications handle unstable dependencies via chaos engineering.
• HTTP Exchange Inspectors - Pauses forwarded HTTP exchanges at specific phases to allow manual inspection and modification.
• Real-Time Traffic Dashboards - Provides a real-time dashboard to visualize incoming HTTP requests, active expectations, and server logs.
• JSON-RPC Implementations - Simulates agent and tool servers by mapping expectations to JSON-RPC 2.0 structures and SSE streams.
• Agent-to-Agent JSON-RPC - Emulates agent-to-agent communication using the JSON-RPC 2.0 protocol, including agent cards and webhooks.
• Model Context Protocol Servers - Emulates Model Context Protocol servers using JSON-RPC 2.0 for AI tool and resource discovery.
• API Response Simulators - Matches incoming requests based on method, path, or body to return pre-configured responses.
• LLM Response Simulators - Simulates chat-completion APIs for AI providers with support for token streaming responses.
• Expectation Conversions - Converts captured real request-response exchanges from a proxied upstream into mock expectations.
• Traffic Interception - Intercepts forwarded traffic at specific phases to allow manual inspection and modification of the data.
• Breakpoint-Based Request Interceptions - Pauses matching requests or response streams via a WebSocket to allow interactive inspection and modification.
• Interactive Breakpoints - Halts proxied traffic at specific phases and opens a callback connection for manual intervention.
• Traffic Proxying - Intercepts live network traffic to record, modify, or pause requests and responses in flight.
• Authentication Flows - Simulates standardized authentication flows for OIDC, OAuth2, SAML 2.0, and SCIM 2.0.
• Identity Providers - Provides mock identity providers that handle discovery and token issuance using standard protocols.
• Runtime Contract Validation - Verifies that a live service conforms to an OpenAPI specification by comparing actual traffic against defined contracts.
• OpenAPI Specification Management - The tool checks recorded traffic or live service responses against an OpenAPI specification for compliance.
• Runtime Compliance Validators - The tool validates a service URL against an OpenAPI specification and generates a pass/fail report.
• Runtime Contract Validators - Validates a service under test against an OpenAPI specification to generate a pass/fail report.
• Response Mocking - Replaces real upstream server responses with mock versions during proxying.
• Real-Time Modifications - Pauses a request or response stream to allow real-time data modification via WebSocket.
• Real-Time Monitoring Dashboards - Offers a real-time dashboard for viewing active requests, configured expectations, and system logs.
• Server Management Dashboards - Displays active expectations, received requests, and server logs through a web-based administration interface.
• Traffic Monitoring Tools - Provides a visual interface to monitor traffic logs, analyze request mismatches, and manage chaos experiments.
• API Contract Testing - The tool runs a specification as a suite of tests against a live service to verify implementation.
• Stateful Mock Gating - Tracks request sequences via named states to simulate complex multi-step business processes and user journeys.
• Behavioral Verification Tools - Verifies that specific requests were received by the server to validate system behavior.
• Dependency Mocking - Mocks, records, and replays HTTP, REST, gRPC, and LLM services to replace external dependencies.
• HTTP Endpoint Simulation - Mocks HTTP and HTTPS endpoints by matching incoming requests against predefined expectations.
• Request Sequence Verification - Asserts that specific requests were received by the server in a particular order and frequency.
• HTTP Service Simulation - Simulates API responses by recording and matching requests for HTTP, gRPC, and WebSocket protocols.
• Language Model Service Mocks - Simulates provider-agnostic language model completions, embeddings, and multi-turn conversations.
• Network Failure Simulations - The tool simulate network failures or abnormal server behavior to verify the resilience of dependent applications.
• Request Expectation Definitions - Allows defining specific responses to be returned when the server receives matching incoming requests.
• Request Matching Rules - Creates rules that specify how the mock server responds to specific incoming HTTP requests.
• Specification Conformance Validation - Checks recorded request and response traffic against an OpenAPI specification to ensure conformance.
• LLM Chat Simulators - Simulates streaming and non-streaming LLM completions and provides endpoints for AI coding assistants.
• Traffic Recorders - Provides tools to capture live HTTP request and response pairs and convert them into reusable mock definitions.
• AI Coding Assistant Integrations - Exposes a protocol endpoint for AI coding assistants to manage mock expectations and debug traffic.
• Agent Debugging Planes - Provides a Model Context Protocol endpoint for AI agents to programmatically manage expectations and debug network traffic.
• LLM Wire-Format Simulations - Mocks responses from language model providers by converting agnostic completions into specific vendor wire formats.
• Local Binary Execution - Launches a self-contained server binary locally without requiring a JVM or container runtime.
• Mock Server Client Libraries - Manages the mock server and proxy through dedicated client libraries for various programming languages.
• Request Body Matchers - Evaluates requests using regular expressions, JsonPath, and XPath to trigger specific mock responses.
• Scenario Sequencing - Executes ordered sequences of chaos stages to verify system stability and halt on objective breach.
• Containerized Server Deployments - Supports deploying the mock server and proxy as Docker containers or via Helm charts.
• Error Handling Simulations - The tool configures a sequence of failing responses followed by a success to test client-side error handling.
• Session State Replicators - Synchronizes mock state and scenario progress across multiple nodes for failover and high availability.
• Cluster State Synchronization - Replicates mock expectations and scenario states across cluster nodes to ensure high availability.
• Helm Chart Deployments - Installs mock server instances into Kubernetes clusters using Helm charts.
• HTTP Request Forwarders - Routes incoming requests to specified hosts, ports, or internal IP addresses to simulate backend dependencies.
• Request Matching Engines - Filters incoming requests using JSON and XML queries to select the appropriate mock response.
• gRPC and GraphQL Simulation - Simulates unary and streaming gRPC calls and synthesizes schema-valid GraphQL responses from SDL.
• Single-Port Protocol Detection - Implements a unified listener that automatically detects and routes multiple network protocols sharing a single TCP port.
• Single Port Protocol Multiplexing - Detects and handles HTTP, HTTPS, SOCKS, and Port Forwarding traffic on a single unified port.
• Frame Modifications - Allows pausing forwarded traffic at specific phases to modify or drop network frames via WebSocket.
• Bidirectional Interception Channels - Pauses live network exchanges via a bidirectional WebSocket channel for real-time inspection and modification.
• Load Generation - The tool drive concurrent outbound traffic using defined scenarios and virtual user profiles to stress test target systems.
• Transparent Proxying - Preserves original destination addresses during proxying to support service mesh and infrastructure testing.
• Upstream Proxy Relaying - Routes unmatched requests to a real upstream service with support for connection pooling and circuit breaking.
• Native Binary Execution - Launches the server via a self-contained native bundle, eliminating the need for a pre-installed JVM.
• Deterministic Time Simulation - Freezes or advances the internal server clock to test time-dependent logic deterministically.
• WASM Body Matching - Implements custom request body-matching rules using WebAssembly to create complex validation logic.
• JWT Route Guards - The tool restricts access to administration endpoints using JWT bearer tokens or other authentication schemes.
• Administrative Endpoint Protections - The tool restricts access to configuration and lifecycle endpoints using OIDC, JWT, or mutual TLS.
• Standalone Runtime Bundling - Ships a standalone runtime bundle to remove dependencies on manual Java or Docker installations.
• API Response - Detects structural differences between actual upstream traffic and mock responses to facilitate stub updates.
• Service Level Objective Validation - Quantitatively verifies if a service meets predefined reliability and performance targets using recorded indicator samples.
• Stateful Scenario Modeling - Models multi-step journeys by gating expectations behind named states and advancing them via successful matches.
• Mock Business Process Modeling - Gates expectations behind named states to model multi-step business processes and user journeys.
• AI Vendor Response Mocks - Mocks AI provider responses by re-encoding completions into vendor-specific shapes.
• AI Agent Observability - Reconstructs agent execution as a call graph to verify that specific tools were called with expected arguments.
• Call Graph Visualizers - Renders a Mermaid-based call graph of an AI agent's execution session for analysis.
• DSL Exports - Exports captured real HTTP traffic as loadable JSON files or Java DSL code.
• Service Level Objective Management - Defines and verifies service-level objectives while driving scheduled chaos experiments to ensure system resilience.
• Performance Goal Validation - Validates if services meet quantitative performance and availability targets based on recorded indicator samples.
• Cost and Token Trackers - Calculates estimated spend and token usage for completions using built-in pricing tables.
• Behavior Drift Analysis - Identifies structural differences between real upstream traffic and mock responses to keep stubs accurate.
• OpenAPI Mock Generators - Automatically creates mock expectations by importing OpenAPI or Swagger specifications.
• Network Latency Simulators - The tool simulate network instability using probabilistic errors, latency distributions, and connection drops to test error handling.
• Containerized Integration Testing - Orchestrates the server and client sidecars using Docker Compose files to validate service behavior.
• Fault Injection Testing - Executes load generation and fault injection experiments to verify service reliability and error recovery.
• Dynamic Mock Outputs - Produces variable output using response templating and custom callbacks to avoid static mock values.
• Dependency Fault Injection - Injects failures or unpredictable behavior into network dependencies to verify system handling of outages.
• Test Isolation - Ensures test execution environments remain independent by resetting server state to prevent cross-test interference.
• Dynamic Response Callbacks - Triggers server-side callbacks to calculate dynamic responses based on incoming request data.
• Mock Server Lifecycle Control - Provides programmatic control to start and stop the mock server in synchronization with test suite execution.
• Mock State Resetting - Clears recorded requests, expectations, and logs after tests to prevent state leakage.
• Mocking Infrastructure Orchestration - Installs and manages mock server instances across Docker, Kubernetes, and web servers.
• Mock Behavior Configuration - Defines dynamic responses, match counts, priorities, and time-to-live settings for mocked services.
• Network Resilience Simulators - The tool simulates instability by introducing latency or dropping connections to test application resilience.
• Network Traffic Simulators - Creates outbound traffic spikes using concurrent virtual users and ramp curves to measure resilience.
• Regex Request Matching - Provides request matching using regular expressions to simulate various API interaction scenarios.
• Resilience Scenario Testing - The tool execute scheduled multi-stage failure scenarios to verify system stability and resilience under heavy stress.
• Runtime Stability Tests - Executes smoke, load, stress, and soak scenarios to evaluate long-term service stability.
• Scenario Sequence Management - Manages a sequence of responses to simulate complex stateful interactions over multiple requests.
• Chaos Experiment Dashboards - Provides visual interfaces for managing and monitoring the progress of active chaos engineering experiments.
• WASM Matching Modules - Executes uploaded WebAssembly binary modules to implement complex request validation logic beyond standard pattern matching.
• Payload Alterations - Provides the ability to modify request and response payloads during the forwarding process between clients and servers.
• Multi-Language Client Libraries - Provides idiomatic libraries in multiple languages to manage server state and expectations.
• Response Templating - Generates response bodies using JavaScript, Velocity, or Mustache templates based on request state.
• Service Virtualization - Mocking and proxy tool for various protocols and chaos engineering.

स्टार हिस्ट्री