This is a production-ready Node.js/Express web application boilerplate designed to jumpstart hackathon projects. The codebase implements a complete user authentication system supporting local email/password, OAuth 2.0/OAuth 1.0a (10+ providers including Google, Facebook, GitHub, Discord, Microsoft), WebAuthn passkeys, and two-factor authentication (TOTP + email). It includes session management with MongoDB, CSRF protection, rate limiting, and custom security measures like timing-safe token comparisons and IP-bound token consumption. Beyond auth, it ships working demos for ~20 third-party API integrations (Stripe, Twilio, GitHub, NYT, Wikipedia, etc.) and AI features powered by LangChain and Groq, including a ReAct agent with SSE streaming, a RAG pipeline with vector search, and LLM-based classification/vision. The repository also provides a sophisticated Playwright-based e2e testing framework using nock-recorded HTTP fixtures, enabling deterministic offline tests without live API keys. All features are organized as deletable modules with a removal checklist to facilitate trimming for production use.
Pa11y is a mature, widely-used automated accessibility testing tool that runs via command-line interface or Node.js API. It drives a headless Chrome browser (via Puppeteer) to load web pages, execute optional user interactions (actions), and then run one or more accessibility test runners (HTML_CodeSniffer and axe-core) against the page. Results are reported in multiple formats (CLI, CSV, JSON, HTML, TSV) and can be filtered by severity, ignored rules, or threshold. The architecture is a monolith library with a thin CLI wrapper, but the runner and reporter systems are modular and extensible via npm packages or local files. Key entry points are `bin/pa11y.js` for CLI and `lib/pa11y.js` for programmatic use. The data flow: launch Chrome, navigate to URL, run actions, inject runner scripts into the page, evaluate accessibility, collect and process issues, output via selected reporter. External dependencies include Puppeteer, axe-core, @pa11y/html_codesniffer, commander, and several utility libraries. The codebase is well-structured, thoroughly tested (unit and integration), and follows modern Node.js practices with async/await and ES6+ features.
This repository is a curated collection of Go packages extracted from the Go standard library's internal packages, plus a few CLI tools built on top of them. The primary package is `testscript`, a robust script-based testing framework that uses txtar archives as test scripts. It provides a declarative way to write integration tests with built-in commands (exec, cmp, stdout, stderr, etc.) and supports external plugins via JSON-RPC. Other notable packages include `diff` (an O(n log n) anchored diff algorithm), `txtar` (a simple human-readable archive format), `lockedfile` (cross-platform atomic file operations with locking), `robustio` (transparent retry for ephemeral I/O errors), `cache` (build artifact cache with SHA256 indexing), and `par` (parallel work executor with memoization). The repo also includes CLI commands: `cmd/testscript` (standalone runner), `cmd/txtar-c` (archive creation), `cmd/txtar-x` (extraction), `cmd/txtar-addmod` (add module to archive), and `cmd/txtar-goproxy` (serve modules from archives). The architecture is modular; each package is independent and can be reused separately. There are thin forwarding layers to `golang.org/x/mod` and `github.com/google/renameio` for compatibility. The codebase demonstrates high craftsmanship in package design, platform-specific abstractions (build tags), and testing utilities. The primary domain is Go tooling and testing infrastructure.
swift-power-assert is a Swift library that provides a `#assert` macro, delivering detailed diagnostic diagrams for assertion failures. The macro, built on SwiftSyntax, rewrites expressions to capture intermediate values and renders a tree of sub-expression results on failure, including word/line diffs for string comparisons. It supports sync and async evaluation, short-circuiting, and custom operators, aiming to replace multiple assertion APIs (XCTest, Nimble, etc.) with a single, universal assert. The package also includes a `StringWidth` module for accurate Unicode width calculations and a comprehensive test suite (2300+ lines) covering diverse expression types. Additionally, the repository contains an interactive web playground with a Deno backend and Monaco editor, allowing users to test the macro in a browser. The codebase is well-structured, with clean abstractions in the runtime library and plugin, though the macro rewriter is tightly coupled to the capture pattern and the generated Unicode width table is large.
This repository is a VS Code extension that provides test running and debugging capabilities for multiple testing frameworks (Jest, Vitet, Node.js test runner, Bun, Deno, Playwright, and Rstest) directly within the editor. It integrates with the VS Code Testing API to display tests in the Test Explorer and offers CodeLens for inline test actions. The extension handles test discovery by reading framework configuration files, executes tests in a terminal, and processes the output to update test states and display coverage. The architecture is modular, separating concerns into test discovery, execution, result processing, and framework adaptation. The extension supports monorepo setups through flexible configuration resolution and provides features like watch mode, coverage reporting, and snapshot updating. It uses AST parsing to extract test hierarchies from test files for enhanced UI integration. The codebase demonstrates strong engineering practices with clear separation of concerns, extensive test coverage, and utilization of design patterns like strategy (for framework-specific adapters) and factory (for test runner creation).
This is a Rust CLI tool called `facts` that implements a fact-driven development workflow. It manages a `.facts` file containing atomic, verifiable claims about a project, each with lifecycle tags (`@draft` → `@spec` → `@implemented`) and optional shell commands for automated verification. The tool provides a rich set of subcommands for listing, adding, editing, removing, linting, and checking facts, along with a terminal UI (TUI) built with Ratatui and Crossterm. It integrates with AI coding agents (Claude, Codex) to verify manual facts via an XML-based verdict protocol, and ships with bundled agent skills for discovery, refinement, and implementation. The project is self-hosting—it uses its own `.facts` file to describe itself—and is distributed via npm, PyPI, and direct install. The architecture is a monolith with clearly separated modules for parsing, writing, ID generation, tag filtering, file locking, and agent communication. The codebase demonstrates strong engineering practices: deterministic round-trip serialization, atomic file writes, advisory locking with stale detection, and a boolean expression evaluator for tag filters. It is actively maintained with a comprehensive test suite and CI/CD pipeline.
Dexmaker is a set of libraries that enable runtime bytecode generation and mocking on Android, primarily to support Mockito test frameworks. It provides two mocking modes: a proxy-based approach (dexmaker-mockito) that generates subclasses via the Dalvik bytecode generation API, and an inline approach (dexmaker-mockito-inline) that uses a JVMTI agent to transform class bytecode at runtime, allowing mocking of final and static methods. The core module (dexmaker) offers a low-level, fluent API for constructing DEX files programmatically, including types, methods, fields, and bytecode instructions. This is complemented by a C++ library (slicer) that reads, writes, and instruments DEX files, used by the inline mock maker to inject hooks into methods. The project is deeply integrated with Android internals, using hidden APIs and native agents, and is actively maintained to keep up with Android platform changes. It serves as the primary mocking solution for Android instrumentation tests where Java bytecode-based mocks (like ByteBuddy) are not available.
Roborazzi is a Kotlin-based visual regression testing framework for Android, Compose Multiplatform (Desktop, iOS), and pure JVM. It integrates with Robolectric to capture screenshots of UI components in unit tests, compares them against golden images, and generates detailed reports (HTML, JSON, PR comments). The framework includes a Gradle plugin that creates record/verify/compare tasks, a JUnit rule for automatic capture, support for GIF/APNG/video recording, UI tree dumps, accessibility checks (via ATF), and experimental AI-powered image assertions (Gemini, OpenAI). It also auto-generates screenshot tests from Compose `@Preview` annotations for both Robolectric and Desktop targets. The architecture is modular: a core library with platform-specific implementations for Android, Desktop, and iOS; a painter module for image encoding/decoding; and separate modules for Compose integration, JUnit rules, preview scanning, and an IntelliJ/Android Studio plugin. The codebase is actively maintained, well-documented, and employs modern Kotlin patterns (KMP, Gradle Configuration Cache, BuildService). It is not a data research project.
This repository provides a comprehensive continuous integration (CI) solution for ROS (Robot Operating System) projects. It automates the process of setting up a ROS environment, building code, running tests, and performing additional checks (such as code formatting, static analysis, and ABI compatibility) across multiple CI platforms including Travis CI, GitLab CI, GitHub Actions, and Bitbucket Pipelines. The system is designed to be highly configurable, supporting a wide range of ROS distributions from legacy versions to the latest releases, and isolates builds using Docker by default to ensure consistency across different environments. The architecture is modular, with clear separation of concerns: entry points for each CI system delegate to a central orchestration script (ci_main.sh), which in turn relies on specialized modules for environment setup, ROS configuration, workspace management, and various build systems (catkin_make, catkin_tools, colcon, etc.). Notable for their reusability and craftsmanship are the utility library (src/util.sh), which provides robust logging, error handling, and timing functions, and the Docker isolation layer (src/isolation/docker.sh), which handles the complexities of running CI jobs in containers including volume mounting, credential forwarding, and container lifecycle management. The project demonstrates strong engineering practices through its maintainability, active support for both ROS1 and ROS2, and adaptability to various CI systems. It has been widely adopted in the ROS community, as evidenced by its usage in numerous repositories. Technical debt is kept low through regular updates to support new ROS distributions and CI platforms, and the codebase avoids common pitfalls in shell scripting by using well-structured functions and consistent error handling.
Artillery is a cloud-scale load testing and functional testing framework for backend services and APIs. It supports multiple protocols (HTTP, WebSocket, Socket.IO, Playwright, PostHog) through a plugin-based engine architecture. The system is primarily a CLI tool (built on oclif) that executes YAML/JSON test scripts defining virtual user flows with configurable arrival phases, payloads, and assertions. It provides distributed execution across local worker threads, AWS Lambda, AWS ECS/Fargate, and Azure ACI, with a bill-of-materials (BOM) system that bundles test dependencies for cloud workers. Metrics are aggregated via a custom Simple Statistics Measurement System (SSMS) supporting counters, histograms (DDSketch), and rates, and can be published to Datadog, CloudWatch, Prometheus, OpenTelemetry, Splunk, New Relic, and other observability platforms. The codebase is a monorepo managed with Turborepo, containing the core runner, platform integrations, first-party plugins (expect, ensure, apdex, slack, fake-data, metrics-by-endpoint, publish-metrics, memory-inspector), and shared type definitions. Key entry points include the `artillery` binary (`packages/artillery/bin/run`), the core runner (`packages/artillery/lib/core/runner.ts`), and platform launchers (`packages/artillery/lib/launch-platform.ts`). External dependencies include AWS SDK, Azure SDK, Playwright, got (HTTP client), and various metric publishing SDKs. The architecture is event-driven, using EventEmitter for lifecycle events and plugin hooks, with a global `global.artillery` object for shared state.
Laravel Dusk is a browser automation and testing library for Laravel applications. It provides a fluent, expressive API for interacting with web pages via ChromeDriver or Selenium WebDriver, enabling end-to-end testing without requiring JDK or Selenium server. The library integrates deeply with Laravel's testing infrastructure (PHPUnit/Pest), offering a TestCase base class, console commands for installation and ChromeDriver management, and a rich set of assertions and interactions (clicking, typing, waiting, screenshots, Vue component inspection). It is architecturally a library that wraps the php-webdriver package, adding Laravel-specific conveniences such as environment management, cookie encryption, authentication helpers, and page/component abstractions. The codebase is well-structured with traits for separation of concerns, macroable support for extensibility, and comprehensive unit and browser test coverage.
Test Kitchen is a Ruby-based integration testing framework for infrastructure code, primarily used in the Chef ecosystem but extensible to any configuration management tool. It provides a CLI (`kitchen`) that orchestrates a lifecycle of actions—create, converge, setup, verify, destroy—across isolated target platforms (VMs, containers, cloud instances) using a plugin architecture for drivers, provisioners, transports, and verifiers. Configuration is defined in YAML files (`.kitchen.yml`) with layered merging (global, project, local) and ERB support. The core library manages instance state via YAML files, structured logging (NDJSON), lifecycle hooks, and concurrency. External dependencies include SSH (net-ssh), WinRM (chef-winrm), and shell execution (mixlib-shellout). The codebase is well-structured with extensive unit and integration tests, but carries some technical debt from legacy Chef provisioner migration and outdated documentation assets.
Moco is a Java library and standalone server for creating mock HTTP servers, primarily used for integration testing. It supports HTTP/HTTPS, REST, WebSocket, SSE, CORS, proxy with failover/playback, recording/replaying, and template-based responses. Architecture is modular: moco-core provides interfaces and implementations (Netty-based server, request matchers, response handlers), moco-runner adds a CLI for JSON-based configuration and standalone execution, and moco-junit/moco-junit5 provide JUnit integration. The system is configured either via a fluent Java API (central `Moco` static factory) or JSON configuration files, making it easy to stub endpoints in tests or as a standalone mock service. It uses Netty for high-performance HTTP serving, Jackson for JSON processing, Freemarker for templates, and Guava for utilities. The codebase is well-structured with clear separation of concerns, extensive tests, and support for modern protocols like HTTP/2 and WebSocket.
This repository is a comprehensive Python tutorial (28k+ stars) covering beginner to advanced topics, with content written in Markdown and published as a static documentation site via MkDocs. The codebase includes a custom tool (`tools/example_runner.py`) that extracts and executes Python code blocks from the Markdown files to verify correctness, integrated into CI. The project also uses modern Python tooling (uv, ruff, pytest) and provides an interactive learning site at learn-py.org. While primarily educational content, the repository demonstrates solid engineering practices with automated testing of examples, dependency management, and CI/CD pipelines.
prove_it is a config-driven hook framework specifically designed for Claude Code, an AI coding assistant. It intercepts lifecycle events (SessionStart, PreToolUse, PostToolUse, Stop, TaskCompleted) and git hooks (pre-commit, pre-push) to run configurable verification tasks. These tasks include shell scripts, AI agent reviews (using Claude subprocesses), and environment variable injection. The tool enforces code quality by blocking or approving AI actions based on pass/fail results, preventing premature completion of tasks. Architecture-wise, prove_it is a Node.js CLI tool (≥18) with a modular design: config loading from layered JSON files, condition evaluation (`when`) for gating tasks, git-backed churn tracking, template expansion, and session state management. The dispatcher module handles all hook events, evaluates conditions, runs tasks synchronously or asynchronously, and returns structured responses to Claude Code. A sophisticated appeal system allows developers to override AI reviewer failures via a backchannel mechanism. The codebase demonstrates strong software engineering practices: extensive unit and integration tests (using node:test), clean functional modules, and a clear separation of concerns. Key reusable patterns include the layered config merging algorithm, the template engine with conditional blocks, and the condition evaluation system with AND/OR semantics. While the tool is tightly coupled to Claude Code's hook API (introducing ecosystem drift risk), its internal architecture is well-crafted and could serve as a reference for building similar verification frameworks. The project is actively maintained with frequent releases (v0.72.0), comprehensive documentation, and real-world example projects. Its quality is solid but not exceptional due to the inherent complexity of the config surface and the reliance on external AI services. The tool effectively solves the problem of AI overconfidence in code generation by forcing verification steps to pass before progress can be made.
OCMockito is an Objective-C mocking library modeled after Mockito for Java. It provides mock objects, stubbing, and verification for unit tests. The library is built as a framework or static library, targeting iOS, macOS, tvOS, watchOS, and visionOS. Its architecture is modular: Core (public API), Mocking (NSProxy-based mock classes), Stubbing (invocation containers and answer objects), Verifying (invocation checkers and verification modes), Invocation (invocation matcher, call stack analysis, printing), and Helpers (chain-of-responsibility for argument getters and return value setters). The primary entry point is the OCMockito.h header, which exposes macros like mock(), given(), verify(), etc. Dependencies include OCHamcrest for matchers and failure reporting, and XCTest for test integration. The codebase demonstrates solid software engineering with extensive unit tests (XCTest), though there are minor maintenance concerns such as duplicated public headers, hardcoded paths in examples, and reliance on global singleton swizzling state that may cause cross-test contamination. Overall, it is a well-maintained and widely used testing library.
Mongoid-RSpec is a Ruby gem that provides RSpec matchers for testing Mongoid documents. It offers a comprehensive set of matchers for validating associations, validations, fields, timestamps, and other Mongoid-specific features. The library is designed to work across multiple versions of Mongoid (from 3.x to 9.x) by using a compatibility layer to abstract away API differences. The code is well-organized into matcher-specific files, demonstrating good separation of concerns and handling of version-specific complexities.
Ember Data Factory Guy is an Ember.js addon designed for factory-based testing in Ember Data applications. It replaces traditional fixtures with factory definitions to generate test data, providing methods like `make`, `build`, and `mock*` for creating and persisting test records. The addon includes request mocking capabilities supporting both Pretender and MSW libraries, scenario management for test setup, and serializer-specific builders/converters for JSONAPI, REST, JSON, and ActiveModel formats. Architecture follows Ember addon conventions with a clear separation between core factory logic, adapter-specific handling, and mocking abstraters. The test application demonstrates usage patterns but is not the primary product.
Helium is a Python library that provides a higher-level, more intuitive API for browser automation, built on top of Selenium. It simplifies common web automation tasks such as clicking buttons, filling forms, handling alerts, switching windows, and dragging elements by allowing developers to reference page elements by their visible labels rather than low-level CSS selectors or XPath expressions. Under the hood, Helium translates each high-level command into Selenium calls, managing implicit waits, iframe traversal, and window focus automatically. The library is designed for both interactive use (e.g., testing) and scripting (e.g., web scraping), and it seamlessly integrates with raw Selenium for advanced use cases. The architecture follows a layered pattern: a public API module (`helium/__init__.py`) exposes functions and GUI element classes; an implementation layer (`helium/_impl/__init__.py`) contains the core logic including element location via XPath construction, frame iteration, and error handling; and utility modules provide geometry, string, and system helpers. The codebase is well-organized with clear separation between API and implementation, though the main implementation file is large and tightly coupled. The library is actively used (over 8,300 stars) and though maintenance is low-effort, it remains functional with recent Selenium compatibility.
nvim-test is a Neovim plugin that provides a unified interface for running tests across multiple programming languages. It integrates with Neovim's terminal system to execute test commands (like jest, pytest, etc.) and displays results in a split window. The plugin features language-specific runners that use tree-sitter queries to identify test functions and navigate to the nearest test from the cursor. Key components include a base Runner class for abstraction, utility functions for file path resolution, and terminal adapters for both built-in and toggleterm implementations. The plugin is actively maintained with recent commits and CI workflows, showing low technical debt as it relies on Neovim's stable APIs and external test runners without complex dependencies.