awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
httprunner avatar

httprunner/httprunner

0
View on GitHub↗
httprunner.com↗

Httprunner

HttpRunner is a multi-protocol network testing framework designed for automating functional and regression tests of HTTP interfaces. It functions as a multi-protocol network tester supporting HTTP/1.1, HTTP/2, WebSocket, TCP, and RPC to validate diverse communication patterns. The project includes specialized engines for API performance testing, data-driven testing, and a test case generator that converts HAR files, curl commands, and Swagger definitions into executable scripts.

The framework is distinguished by its ability to separate test logic from business data via a data-driven execution engine and its support for high-concurrency load testing through distributed load orchestration. It features a multi-language plugin system that allows users to extend the core engine with custom validation and processing logic written in Go, Python, or Java.

The project covers a broad range of capabilities, including complex scenario modeling for user workflow simulation, response validation, and detailed network performance analysis. It provides tools for distributed load generation, geographic network probing, and the integration of automated test suites into CI pipelines.

The core testing engine can be executed via a command-line interface or wrapped within the Python testing ecosystem using a dedicated runner.

Features

  • API Testing - Provides a comprehensive framework for validating the functionality, performance, and integration of API interfaces.
  • Automated API Testing - Automates functional and regression tests for HTTP interfaces using structured data and scripted validation.
  • Multi-Protocol Network Testers - The project validates diverse network communication patterns using HTTP, WebSocket, TCP, and RPC.
  • API Testing Frameworks - A framework for automating functional and regression tests of HTTP interfaces using structured data and scripting.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
4,279 stars·1,283 forks·Go·Apache-2.0·36 views
  • Custom Test Logic Integrators - Supports integrating external scripts in multiple languages to handle complex business logic during tests.
  • API Test Case Generators - Transforms HAR files, Postman collections, Swagger definitions, and curl commands into executable test scripts.
  • Multi-Language Plugin Frameworks - Implements a plugin architecture supporting extensions written in Go, Python, and Java.
  • Network Protocol Testing - Executes functional and performance tests for network protocols to validate consistent and reliable system behavior.
  • Multi-Protocol Functional Tests - Runs functional tests across multiple communication protocols to ensure network data transfers correctly between systems.
  • Multi-Protocol Transport Abstraction - Provides a unified internal interface to abstract interactions across HTTP, WebSocket, TCP, and RPC protocols.
  • Plugin-Based Logic Extensions - Allows loading external scripts and binaries to execute custom logic during the request lifecycle.
  • Framework Extension Points - Provides customizable hooks and plugin functions to extend the core framework logic.
  • Load Simulation Testing - The project executes high-concurrency stress tests using a high-performance engine to simulate thousands of virtual users.
  • API Regression Testing - Runs automated interface tests across business lines to verify functional requirements and improve regression efficiency.
  • Automated Performance Testing - The project runs stability and speed evaluations through a command line interface using diverse execution strategies.
  • Data-Driven Testing - Executes test cases repeatedly using external datasets from CSV or JSON files to validate diverse input scenarios.
  • Distributed Load Generation - Coordinates controller and worker nodes to generate high-concurrency traffic for system stability and performance measurements.
  • Distributed Performance Testing Engines - Coordinates worker nodes to simulate concurrent users and distributed load for system stability measurement.
  • Scenario Sequence Management - Coordinates data flow between interdependent calls using extractors and variables to build linked test scenarios.
  • Concurrency Burst Testing - The project executes high-volume request bursts using a high-speed engine to measure system behavior under stress.
  • Performance Testing Frameworks - Provides a framework to measure system stability and response times under high concurrent load.
  • Response Parameter Extraction - Parses response data using queries and regular expressions to pass values between subsequent test steps.
  • API Scenario Orchestrations - Creates dependent request chains and sophisticated test workflows using variables and data extraction.
  • Variable Scope Management - Manages the lifecycle and visibility of test variables across different scopes to maintain flexible configurations.
  • Test Execution Reports - The project creates documents that summarize execution metrics and provide detailed logs of requests and responses.
  • Sequential Test Executions - Executes network requests in a specific order to simulate user behavior and maintain transaction boundaries.
  • User Workflow Modeling - Builds intricate testing workflows and data-driven scenarios using variables and validation hooks to simulate user behavior.
  • User Workflow Simulation - Simulates complex real-world user interactions through multi-step test scenarios using variables and validation rules.
  • Virtual User Simulation - The project stress tests system capacity by mimicking high volumes of virtual users via a distributed execution engine.
  • API Response Validation - Verifies that API response fields and status codes match expected results using extraction and comparison logic.
  • Performance Metric Aggregators - The project groups multiple interface requests into a single transaction to measure performance based on real-world scenarios.
  • Test Definition Conversions - Transforms test definitions between YAML, JSON, and native formats for cross-tool compatibility.
  • Test Suites - Groups multiple test cases into a single collection for batch execution from files or directories.
  • CI Pipeline Integrations - Integrates automated test suites into CI pipelines to validate modules and prevent regressions during code commits.
  • HTTP/2 Support - The project runs requests using the HTTP/2 protocol to verify the performance and functional behavior of web services.
  • HTTP Request Performance Analysis - The project collects detailed timing metrics for DNS resolution, TCP connection, and SSL handshaking during requests.
  • Multi-Protocol HTTP Support - The project checks if a server communicates via HTTP/2 or HTTP/1.1 to ensure correct protocol negotiation.
  • WebSocket Connection Management - The project establishes connections with custom parameters, handles heartbeats, and closes sessions with specific status codes.
  • HAR File Parsers - Converts exported HTTP Archive (HAR) files into automated test cases for rapid reproduction of network traffic.
  • WebSocket Data Assertions - The project extracts parameters from responses and performs assertions on returned data to verify communication correctness.
  • Environment Variable Sets - Manages sets of fixed variables to ensure consistency across different deployment environments.
  • Geographic Probes - The project probes domains and resource requests from specific geographic regions to optimize network latency.
  • Latency Metrics - The project captures detailed latency data for DNS resolution, TCP connection, and data transmission.
  • Synthetic User Monitoring - The project simulates user behavior using real devices and global networks to identify issues and causes.
  • Request Burst Synchronization - The project forces virtual users to wait at a rendezvous point before triggering simultaneous requests to simulate spikes.
  • Traffic Weight Configuration - The project defines virtual user weights for specific test cases to simulate realistic traffic distribution during load testing.
  • CI Integration Testing - Integrates automated API test suites into CI pipelines to detect regressions during commits.
  • CI Test Execution - Automatically executes specific test modules whenever code is committed to a version control system.
  • API Request Configurations - Sets shared domains and request headers to be used globally across multiple test modules.
  • Setup and Teardown Hooks - Includes hooks to execute setup and teardown functions for resource allocation and cleanup around test steps.
  • Interface Latency Profiling - The project measures timing for DNS, TCP, TLS, and server processing to identify the cause of slow API responses.
  • Localized Payment Testing - Tests payment flows using regional methods and local networks to identify checkout failure points.
  • Schema-Driven Definitions - Transforms structured YAML and JSON data formats into executable sequences of network request steps.
  • Request-to-Test Conversions - Turns captured network requests directly into executable test scenarios to accelerate the creation of test suites.
  • CLI Test Runners - Provides a command-line interface for executing automated interface and performance test suites.
  • Pytest Wrappers - Wraps the core testing engine within a standard pytest runner for improved CLI control and reporting.
  • Test Scenario Synchronization - Synchronizes test data and scenarios to enable reuse across both functional and performance testing domains.
  • API Test Collections - Groups API tests into hierarchical collections organized by functional module or service for better management.
  • User Behavior Simulation - The project inserts fixed or random delays between test steps to mimic real human interaction and browsing behavior.
  • WebSocket Interface Testing - The project performs full-duplex communication by opening connections, sending messages, and closing sessions.

    • Star history

    Star history chart for httprunner/httprunnerStar history chart for httprunner/httprunner

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Projects sharing features with Httprunner

    These projects share indexed features with Httprunner. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • artilleryio/artilleryA

      artilleryio/artillery

      9,003View on GitHub↗

      Artillery is a Node.js load testing tool and performance testing framework used to generate high-volume synthetic traffic. It functions as a distributed load generator capable of spawning traffic from cloud infrastructure and Kubernetes clusters to simulate massive user loads. The project distinguishes itself through its ability to execute browser-based load tests using headless browsers to measure client-side rendering and real user journeys. It also serves as a protocol testing framework that validates multiple communication standards and real-time protocols through complex, multi-step tran

      JavaScript
      View on GitHub↗9,003
    • loadimpact/k6loadimpact avatar

      loadimpact/k6

      30,891View on GitHub↗

      k6 is a developer-centric load testing suite and command-line load generator designed for network performance validation. It functions as a JavaScript load testing tool that utilizes a Go-based runtime engine to simulate concurrent user traffic and validate API responses across HTTP, gRPC, and WebSockets. The project distinguishes itself by using code rather than a graphical interface to define workload scenarios and performance thresholds. It features a pluggable protocol architecture and an extension ecosystem that allows for the addition of custom protocols and specialized testing capabili

      Go
      View on GitHub↗30,891
    • getanteon/anteonG

      getanteon/anteon

      8,526View on GitHub↗

      Anteon is a distributed load testing platform and automated performance testing suite designed to simulate high-traffic user scenarios and measure system performance across multiple global locations. It functions as an infrastructure anomaly detector and a service dependency mapper, providing a performance monitoring dashboard to track real-time resource usage across cluster instances. The project distinguishes itself by combining distributed traffic generation with service dependency mapping to identify system bottlenecks through network-level tracing. It incorporates an automated validation

      Go
      View on GitHub↗8,526
    • intuit/karateintuit avatar

      intuit/karate

      8,879View on GitHub↗

      Karate is an end-to-end testing framework and API test automation tool used to validate REST and SOAP APIs, drive browser interactions, and measure system performance. It functions as a unified solution for executing automated tests across both API backends and web frontends. The framework utilizes a custom domain specific language and Gherkin-style feature mapping to define requests and assertions. It includes an API mocking server to simulate backend responses, enabling development and integration testing without live dependencies. The tool covers a broad range of functional testing catego

      Java
      View on GitHub↗8,879
    Compare all 30 related projects→

    Frequently asked questions

    What does httprunner/httprunner do?

    HttpRunner is a multi-protocol network testing framework designed for automating functional and regression tests of HTTP interfaces. It functions as a multi-protocol network tester supporting HTTP/1.1, HTTP/2, WebSocket, TCP, and RPC to validate diverse communication patterns. The project includes specialized engines for API performance testing, data-driven testing, and a test case generator that converts HAR files, curl commands, and Swagger definitions into executable…

    What are the main features of httprunner/httprunner?

    The main features of httprunner/httprunner are: API Testing, Automated API Testing, Multi-Protocol Network Testers, API Testing Frameworks, Custom Test Logic Integrators, API Test Case Generators, Multi-Language Plugin Frameworks, Network Protocol Testing.

    Which projects share features with httprunner/httprunner?

    Projects with overlapping indexed features include: artilleryio/artillery — Artillery is a Node.js load testing tool and performance testing framework used to generate high-volume synthetic… loadimpact/k6 — k6 is a developer-centric load testing suite and command-line load generator designed for network performance… getanteon/anteon — Anteon is a distributed load testing platform and automated performance testing suite designed to simulate… intuit/karate — Karate is an end-to-end testing framework and API test automation tool used to validate REST and SOAP APIs, drive… grafana/k6 — k6 is a performance testing framework used to measure the scalability and stability of network services and APIs. It… postmanlabs/newman — Newman is a headless API client and command line tool for executing Postman collections. It serves as an API test…