Mockoon is a multi-platform API mocking tool that runs mock servers locally or remotely. It is built as a monorepo with six npm packages: @mockoon/commons (shared models, migrations, OpenAPI converter), @mockoon/commons-server (core Express-based mock server engine with templating and response rules), @mockoon/app (Electron desktop application with an Angular renderer), @mockoon/cli (oclif-based command-line interface), @mockoon/cloud (cloud sync library), and the deprecated @mockoon/serverless wrapper. The architecture cleanly separates the core server logic from the delivery mechanisms. The MockoonServer class provides an HTTP/HTTPS server with a sophisticated response rule engine, a Handlebars templating system with over 100 custom helpers (including deep Faker.js integration), CRUD operations on data buckets, WebSocket support, proxy mode, and a full admin API. The desktop app uses a Redux-like state management pattern with RxJS, ensuring predictable and testable UI state transitions. The codebase demonstrates high craftsmanship in several areas. The ResponseRulesInterpreter is a self-contained DSL for matching HTTP requests to mock responses. The TemplateParser provides an extensible helper registration system. The data migration system in commons is a textbook example of handling schema evolution for JSON-based data models. The project is actively maintained with a robust CI/CD pipeline, though it carries some technical debt such as a deprecated serverless package and disabled strict TypeScript mode in the desktop app.
Mimesis is a Python library for generating high-quality, locale-aware fake data, intended for use in testing, database seeding, API mocking, and data anonymization. Unlike simpler lorem-ipsum generators, it produces realistic names, addresses, dates, financial data, internet-related strings, and more, across 47 locale variants. The architecture is modular: locale-independent and locale-dependent providers (e.g., Person, Address, Internet) load curated JSON datasets, while a suite of schema tools (Field, Fieldset, Schema, SchemaBuilder) allows declarative generation of flat or relational synthetic datasets with lazy evaluation, dependency resolution, and export to CSV/JSON/pickle. A custom Random class with weighted selection and deterministic seeding ensures reproducibility, and optional plugins integrate with factory_boy and pytest-randomly. The codebase is well-structured, extensively typed (mypy strict), and thoroughly tested, with a strong emphasis on performance (~20-30x faster than comparable libraries like Faker). External runtime dependencies are minimal; the only optional ones are pytz and factory-boy.
Microcks is a cloud-native API mocking and testing platform that ingests API specifications (OpenAPI, AsyncAPI, gRPC, GraphQL, Postman, SoapUI, HAR, and protobuf) and dynamically generates live mock endpoints and contract conformance tests. It supports REST, SOAP, GraphQL, gRPC, and asynchronous protocols (Kafka, RabbitMQ, MQTT, NATS, WebSocket, Amazon SQS/SNS, Google PubSub). The architecture consists of a main Spring Boot web application with an Angular frontend, a separate Quarkus-based async minion for event-driven mocking and testing, and optional dependencies on MongoDB, Keycloak, Kafka, and external message brokers. The system provides a rich set of features: dynamic response dispatching based on request parameters, scriptable mocks (Groovy/JavaScript), a template engine for dynamic content, SLA management, webhook notifications, AI-assisted sample generation via OpenAI, and OpenTelemetry-based observability. It is a well-engineered, modular project with extensive test coverage and a clean separation of concerns.
This repository provides a REST API for retrieving random words with optional filtering by language, length, count, and difficulty (based on Wikipedia word frequency). The application is built with Scala using the Cask web framework, loads word lists from JSON files at startup, and uses Redis for IP-based rate limiting. Key features include difficulty filtering via parallel Wikipedia API calls with caching and fallback mechanisms, efficient random word selection algorithms, and multi-language support through community-contributed JSON files. The architecture is monolithic with clear separation of concerns across service objects for language handling, word selection, rate limiting, and external API integration.
govcr is a Go library that records and replays HTTP/HTTPS interactions for testing purposes, acting as an HTTP mock. It wraps an http.Client to intercept requests, either playing back recorded responses from cassette files (JSON) or making live requests and recording them. The library supports various modes (normal, live-only, offline, read-only), cassette encryption (AES-GCM, ChaCha20Poly1305), multiple storage backends (local filesystem, AWS S3), flexible request matching, and request/response transformation via mutators. The architecture centers around a custom http.RoundTripper implementation that integrates cassette storage, request matching, mutation systems, and encryption layers.
JSON Server v1 (beta) is a CLI tool and library that spins up a fully functional REST API from a JSON or JSON5 file. It is built on top of lowdb for data persistence and @tinyhttp/app for HTTP handling. The architecture is a clean three-layer design: a CLI entry point (bin.ts) that wires file watching and server startup, an Express-like app layer (app.ts) that defines routes and parses query parameters, and a service layer (service.ts) that encapsulates all data access, filtering, pagination, and relationship embedding. The system supports advanced query capabilities including field operators (gt, lt, in, contains, etc.), JSON-based _where queries, sorting, pagination with navigation metadata, and resource embedding via _embed. It also handles referential integrity on deletes by nullifying foreign keys or cascading dependent deletions. The codebase demonstrates solid TypeScript craftsmanship with strict mode enabled, modern ESM modules, and a clear separation of concerns. Notable engineering patterns include the NormalizedAdapter wrapper that enforces string IDs and strips $schema on read while re-injecting it on write, and the Observer adapter that intercepts lowdb read/write lifecycle events to enable file-watch reloading without feedback loops. The query parsing layer cleanly separates URLSearchParams-based operator syntax from raw JSON _where objects, with proper type coercion for booleans, null, and numbers. The project is in active beta (v1.0.0-beta.15) with recent commits, CI via GitHub Actions, and a pre-commit hook running tests. It targets Node.js >=22.12 and leverages experimental TypeScript stripping for development. Dependencies are current and well-chosen (lowdb v7, @tinyhttp v3, eta v4). The test suite uses Node's built-in test runner and covers the service layer, query parsing, pagination, and full HTTP integration tests.
The antd-admin repository is a monorepo providing two production-ready admin application templates (basic and with-lingui) and a CLI tool for scaffolding new projects from these templates. Built with React 19, Ant Design 6, TanStack Router & Query, Zustand, Zod, Vite+, MSW, and Playwright, it includes features like JWT authentication, role-based access control, CRUD operations with optimistic updates, URL-synchronized table state, dark theming, and optional i18n via Lingui. The architecture emphasizes modularity, with reusable hooks, components, and mocking utilities that encapsulate complex patterns such as data fetching mutations, schema-aware API mocking, and persistent state management.
Pegomock is a mocking framework for the Go programming language that generates mock implementations of interfaces for testing purposes. It provides a DSL inspired by Mockito for defining mock behavior and verifying interactions. The project consists of a core library for creating and verifying mocks in tests, a CLI tool for generating mock code from interfaces, and a watch mode that automatically regenerates mocks when interfaces change. The architecture follows a modular design with separate components for the DSL, mock generation, and CLI functionality.
fakesnow is a Python library that provides a local, in-memory fake implementation of the Snowflake database connector. It uses DuckDB as the underlying SQL engine and sqlglot to transpile Snowflake SQL dialect into DuckDB-compatible queries. The library monkey-patches `snowflake.connector.connect` and `snowflake.connector.pandas_tools.write_pandas`, enabling developers to run Snowflake-dependent code entirely locally without a real Snowflake account. It also includes an optional HTTP server that mimics Snowflake's REST API, allowing non-Python clients (JDBC, Go, .NET) to connect. The project is primarily a test double and development tool, with a strong emphasis on behavior equivalence to real Snowflake. It supports a wide range of Snowflake SQL features, including DDL, DML, COPY INTO, MERGE, semi-structured data (JSON), sequences, stages, file formats, and session variables. The codebase is well-structured with a modular transform pipeline, extensive tests, and CI/CD pipelines for release. However, some features are partially implemented or marked as not yet supported, and the project is tightly coupled to evolving dependencies (DuckDB, sqlglot) which may cause drift.
Stripe-ruby-mock is a Ruby library that provides in-memory mocking of the Stripe API for testing purposes. It intercepts Stripe HTTP requests and returns simulated responses, enabling offline, deterministic testing without real API keys or network access. The library supports both local mocking (via `StripeMock.start`/`stop`) and a remote mock server for integration tests across processes. It covers a wide range of Stripe endpoints including charges, customers, subscriptions, invoices, payment intents, and webhooks, with extensive shared RSpec examples and webhook fixtures. The architecture follows a modular request-handler pattern, with helpers for token generation, param validation, and search simulation. While the codebase is well-structured and popular (996 stars), it shows signs of maintenance strain (199 open issues, call for core maintainers) and technical drift (vendored Trollop CLI parser, outdated webhook fixtures, limited Stripe API version coverage). It remains a valuable tool for legacy Stripe testing but may require updates to fully align with current Stripe API changes.