Assure your AI deployment - across enterprise and real world
We assure that your AI works as intended. Safely and securely.
13 Best Integration Testing Tools and Frameworks in 2026
Compare 13 integration testing tools and frameworks for 2026, grouped by the boundary each one tests, with a real WireMock run on TestMu AI HyperExecute.
Last Updated on:
A checkout service can pass every unit test and still fail in staging the first time the carrier's rates API answers with a 503 or takes three seconds to respond. Unit tests swap that call for a fake; integration testing checks what the code does when it crosses the real boundary.
In Postman's 2025 State of the API report, a survey of over 5,700 developers, architects, and executives, functional and integration testing both reach 67% adoption, while contract testing lags at only 17%.
The 13 integration testing tools and frameworks below are grouped by the boundary each one tests: a service and its real dependencies, HTTP and SOAP APIs, stubs and contracts, message brokers, the UI-to-backend path, and embedded C and C++ code. The order follows those boundaries and is not a ranking. TestMu AI is our own platform, and it sits in the UI and scale group because it runs these suites rather than replacing them.
For one boundary I ran the tests for real: a pytest suite against WireMock, started as a background service on a TestMu AI HyperExecute VM, with a healthy, a failing, and a slow third-party API. The code, the YAML, and the console output are in the last section.
Overview
The best integration testing tool is the one built for the boundary you test. Testcontainers covers a service and its real databases or message brokers, and WireMock covers the third-party APIs you cannot control. Most teams pair them with an API tool such as Postman or REST Assured and run the suite on every pull request.
What Are the Best Integration Testing Tools by Use Case?
- Best for real databases and brokers: Testcontainers - starts throwaway PostgreSQL, Kafka, or other containers from test code in Java, Go, .NET, Node.js, and Python. Open source under MIT; needs a Docker-compatible runtime.
- Best for API workflows with little code: Postman - chains requests into collections with JavaScript assertions and runs them in CI through the Postman CLI. Free single-user plan.
- Best for Java HTTP assertions: REST Assured - adds a given/when/then syntax for calling REST endpoints to JUnit and TestNG suites. Open source under Apache 2.0; version 6 needs Java 17.
- Best for API tests and mocks in one syntax: Karate - writes API tests, test doubles, and reusable performance tests in readable feature files. Open source under MIT; version 2 needs Java 21.
- Best for SOAP services: SoapUI - the open-source edition runs SOAP and REST functional tests and mock services from a desktop app. Open source under EUPL 1.1.
- Best for faking third-party APIs: WireMock - a stub server that returns scripted responses, error statuses, and delays, so a test can reproduce a provider outage on demand. Open source under Apache 2.0.
- Best for microservice contracts: Pact - verifies a provider against the requests and responses its consumers recorded, and its can-i-deploy check gates releases. Open source, in more than 10 languages.
- Best for enterprise middleware: IBM DevOps Test Integrations and APIs - the renamed Rational Integration Tester tests and virtualizes MQ, JMS, Kafka, and other SOA messaging integrations. Commercial.
- Best for message-based systems: Citrus - acts as both client and server over Kafka, JMS, HTTP, and other transports and validates each payload. Open source under Apache 2.0; needs Java 17.
- Best for UI-to-API checks: Playwright - checks the page and the server-side state in one test and can replace a backend response with a stub. Open source under Apache 2.0, with JavaScript, Python, Java, and .NET bindings.
- Best for running integration suites at scale: TestMu AI - HyperExecute runs any command-line test runner on cloud VMs and starts a mock or app server as a background service beside the tests. Free to start.
- Best for safety-certified C and C++: VectorCAST - unit- and integration-tests embedded C, C++, and Ada code with coverage reports for standards such as DO-178C and ISO 26262. Commercial.
- Best for requirements-traced embedded testing: LDRA - automates unit and integration test harnesses on host or target hardware and links each test to its requirement. Commercial, with a 30-day trial.
What Are the Best Integration Testing Tools?
The best integration testing tools in 2026, by the boundary they test, are Testcontainers, Postman, REST Assured, Karate, SoapUI, WireMock, Pact, IBM DevOps Test Integrations and APIs, Citrus, Playwright, TestMu AI, VectorCAST, and LDRA. I checked every tool against its own documentation and release pages in October 2026, and each entry names at least one limitation.
| Tool | Boundary it tests | Runs on | License |
|---|---|---|---|
| Testcontainers | A service and its real databases or brokers | Java, Go, .NET, Node.js, Python, and more | MIT; Testcontainers Cloud is paid |
| Postman | HTTP API workflows | Desktop and web app, Postman CLI | Free single-user plan, paid team plans |
| REST Assured | HTTP APIs from Java tests | JVM, Java 17 or later for 6.x | Apache 2.0 |
| Karate | HTTP APIs plus mocks | JVM, Java 21 or later for v2 | MIT; paid extensions |
| SoapUI | SOAP and REST services | Desktop app | EUPL 1.1; ReadyAPI is paid |
| WireMock | Third-party HTTP dependencies, stubbed | JVM, standalone JAR, Docker | Apache 2.0; WireMock Cloud is paid |
| Pact | Contracts between services | More than 10 languages | MIT or Apache 2.0 by language; PactFlow is paid |
| IBM DevOps Test Integrations and APIs | Enterprise middleware and SOA messaging | Installed with DevOps Test Workbench | Commercial |
| Citrus | Message-based integrations | JVM, Java 17 or later | Apache 2.0 |
| Playwright | UI to backend | JavaScript and TypeScript, Python, Java, .NET | Apache 2.0 |
| TestMu AI | Running integration suites at scale | Cloud VMs on Linux, Windows, and macOS | Free to start, paid plans |
| VectorCAST | Embedded C, C++, and Ada | Host, simulator, or target | Commercial |
| LDRA | Embedded code with requirements traceability | Host, simulator, or target | Commercial, 30-day trial |
1. Testcontainers
Testcontainers is an open-source library that starts throwaway instances of databases, message brokers, web browsers, or anything else that runs in a Docker container, straight from test code. Use it where a mock would hide the bug: a query, a migration, or a client library that only fails against the real engine and version you run in production.
- Languages - implementations exist for Java, Go, .NET, Node.js, Python, Rust, Ruby, PHP, and more. Docker sponsors the Java and Go libraries, and community contributors maintain the rest.
- Modules - preconfigured modules cover relational and NoSQL databases and message brokers, so a PostgreSQL or Kafka dependency takes a few lines of setup.
- Ownership - Docker acquired AtomicJar, the company behind Testcontainers, in December 2023. The library stays MIT-licensed, and Testcontainers Cloud is the commercial option for running the containers remotely.
The Node.js package alone was downloaded 27,845,943 times in September 2026, according to npm's download count for the testcontainers package.
Testcontainers needs a Docker-API compatible container runtime on the machine that runs the tests, and its docs say alternative runtimes are not actively tested. Java teams moving to version 2.0 should also expect renamed module artifacts, so org.testcontainers:mysql becomes org.testcontainers:testcontainers-mysql.
2. Postman
Postman is an API platform for building and using APIs, and its collections double as integration tests: chain requests such as creating an order and reading it back, then assert on each response with pm.test and pm.expect in JavaScript. It sends HTTP, GraphQL, gRPC, WebSocket, and MQTT requests, and it can make SOAP calls over HTTP.
- CI runs - Postman now recommends the Postman CLI for running collections in pipelines and says Newman is no longer maintained, so start new pipelines on the CLI.
- Mock servers - collection-based mock servers stand in for an API that is not built yet, on every plan, including Free.
- Free plan - a single-user plan with unlimited collection runs; scheduled runs count toward its monthly monitoring allowance.
Postman's mock servers handle HTTP requests only, and a collection does not start databases or brokers, so run it against an environment where those dependencies already exist. The Postman API testing guide covers collections, scripts, and command-line runs in more depth.
3. REST Assured
REST Assured gives Java a given/when/then syntax for calling and checking REST services, so HTTP integration tests live in the same JUnit or TestNG suite as the rest of the codebase. Version 6.1.0 shipped on October 9, 2026, and the 6.x line requires Java 17 or later.
- Spring support - the spring-mock-mvc and spring-web-test-client modules test Spring MVC and WebFlux controllers without starting a server.
- It pairs naturally with Testcontainers for the database behind an endpoint and WireMock for the services that endpoint calls.
- Cloud runs - TestMu AI documents running REST Assured API tests on HyperExecute with a Maven project and a hyperexecute.yaml file.
Teams still on Java 8 or 11 have to stay on the 5.5.x line, and REST Assured runs only on the JVM, with no commercial support offering. Johan Haleby maintains it under the Apache 2.0 license with community contributors, and the repository has 7.1k stars on GitHub.
4. Karate
Karate combines API testing, mocks, performance testing, and UI automation in one open-source framework, with tests written as readable Gherkin-style feature files instead of Java classes. The repository has 9.0k stars on GitHub, and Karate v2, the current major version, requires Java 21 or later.
- Test doubles - standalone mock servers with stateful behavior, so a consumer team can stand up a fake provider in the same syntax it tests with.
- Performance reuse - existing Karate functional tests run as Gatling performance tests.
- Parallel runs - the parallel runner works independently of the build tool.
gRPC, Kafka, and WebSocket testing need Karate Labs' commercial extensions, and the docs warn that the mock server is not a hardened, internet-facing application server, so keep it inside test environments.
5. SoapUI
SoapUI is a free, open-source functional testing tool for APIs and web services, maintained by SmartBear alongside its commercial ReadyAPI product. Its desktop app runs functional tests against SOAP, REST, and GraphQL APIs, and a JDBC Request test step queries the database directly, which covers the API-plus-database check many SOA integrations need.
- MockServices - mimic SOAP and REST services before they are implemented, so consumers can be tested early.
- Command-line runs - testrunner.bat or testrunner.sh runs functional tests from a CI job.
- Release status - version 5.10.0 shipped on June 2, 2026, and its notes say it mainly addresses known security vulnerabilities.
SoapUI's own documentation draws the open-source boundary: data-driven testing is not available, exporting command-line results in various formats needs a ReadyAPI license, and security testing now sits in ReadyAPI. The open-source edition is licensed under EUPL 1.1 and suits teams maintaining WSDL-based services better than teams starting new REST APIs.
6. WireMock
WireMock simulates the HTTP APIs your code depends on, so a test decides what the third party returns: a canned response, an error status, a malformed body, or a slow reply. That makes it an open-source route to service virtualization for HTTP, and it runs embedded in Java tests, as a standalone JAR, or from its official Docker image.
- Request verification - the admin API reports whether a request matching a pattern arrived, which the run in this guide used to check the ZIP and weight parameters.
- Fault injection - fixed delays, malformed response chunks, and connection resets, although the docs note a reset tends to hang rather than reset on Windows.
- Record and playback - proxy a real API once and save its responses as stub mappings.
- .NET port - WireMock.Net brings the same model to C# test suites.
WireMock is Apache 2.0-licensed, with WireMock Cloud as the commercial hosted version, and the repository has 7.4k stars on GitHub. The stable line is 3.13.2, which needs Java 11 or later; version 4.0 is still in beta with Java 17 as its baseline.
7. Pact
Pact is a code-first tool for consumer-driven contract testing of HTTP and message integrations. The consumer's tests record the requests it sends and the responses it relies on, and the provider's build replays that contract against the real service, so a renamed field fails the provider's pipeline instead of production.
- Languages - implementations exist in more than 10 languages, including Java, JavaScript, .NET, Go, Python, Ruby, and Rust.
- Pact Broker - shares contracts and verification results between teams; the open-source broker is self-hosted.
- can-i-deploy - a check a pipeline runs to learn whether a version is safe to release against the versions it talks to.
The JavaScript implementation was downloaded 2,538,625 times in September 2026, according to npm's download count for @pact-foundation/pact.
Pact works only when both sides adopt it; its own docs list APIs whose other team will not use Pact as a poor fit. PactFlow, a commercial fork of the broker, belongs to SmartBear. Bas Dijkstra, a test automation consultant and trainer, walks through the approach in this TestMu AI Voices of Community session:
8. IBM DevOps Test Integrations and APIs
IBM DevOps Test Integrations and APIs is the new name of Rational Integration Tester from version 11.0.0, released on December 12, 2023, and IBM describes it as an integration testing and virtualization tool. It offers a scripting-free environment for testing SOA messaging and business process integrations, and version 12.0.0 shipped on September 24, 2026.
- Middleware coverage - documented testing for IBM WebSphere MQ, JMS, Apache Kafka, HTTP, TCP and UDP transports, and applications on z/OS.
- Virtualization - virtual services built in the tool deploy to IBM DevOps Test Virtualization, so a team can test against a mainframe or partner system it cannot reach.
- Recording - it records SOA message conversations plus HTTP(S) and JDBC traffic to seed tests and stubs.
It is commercial: licensed customers download it from IBM Passport Advantage and install it as part of DevOps Test Workbench. HCL ships its own edition under the same name, formerly HCL OneTest API, and IBM's docs note that .NET objects can be built and validated but not tested directly.
9. Citrus
Citrus is an open-source test framework focused on messaging applications and microservices. Within a test it acts as both client and server, so it can send a request to the system under test and play the downstream service that receives the next message, over HTTP, Kafka, JMS, SOAP, FTP and SFTP, SMTP mail, SQL, SSH, and more.
- Test languages - Java, XML, YAML, Groovy, and Cucumber (Gherkin), run as ordinary JUnit Jupiter or Spring Boot tests in Maven or Gradle.
- Infrastructure inside the test - Testcontainers modules prepare brokers and databases, and more than 300 Apache Camel components extend its reach.
- CI reports - results come out as JUnit XML, which Jenkins and similar servers import.
Citrus 5.0.2, released on September 25, 2026, is the current version, and like the 4.x line it needs Java 17 or later. It runs only on the JVM, under the Apache 2.0 license, with no paid edition.
10. Playwright
Playwright covers the UI-to-backend boundary from one test. Its API client prepares server-side state before the browser visits the app and validates server-side post-conditions after the browser acts, while page.route with route.fulfill replaces a backend response with a stub and routeFromHAR replays a recorded session.
- Languages - bindings for JavaScript and TypeScript, Python, Java, and .NET, with the same core browser features in each.
- Release - @playwright/test 1.64.0 shipped on October 7, 2026, under the Apache 2.0 license.
The test runner package was downloaded 261,320,533 times in September 2026, according to npm's download count for @playwright/test.
page.route sees only the requests the page itself makes, and requests a Service Worker takes over are invisible to it, so Playwright cannot stub a call between two backend services; pair it with WireMock for that. The Playwright API testing guide and the Playwright API mocking tutorial walk through both techniques.
11. TestMu AI (Formerly LambdaTest)
TestMu AI runs the suites the other tools on this list produce. Its test orchestration cloud, HyperExecute, reads one hyperexecute.yaml file that names the runtimes to install, the commands to run, and how to split them across fresh Linux, Windows, or macOS VMs. TestMu AI's HyperExecute page puts the result at up to 70% faster than a traditional grid.
- Background services - a HyperExecute background service starts an app server, a database, or a mock such as WireMock on the same VM as the tests, from the pre stage until the post stage ends. The run in the last section depends on it.
- Any command-line runner - the YAML runs whatever test command you give it, so pytest suites, Maven builds with REST Assured or Karate, and npm-based Playwright suites move over without a rewrite.
- Browser-level integration - Automation Cloud runs Selenium, Playwright, and Cypress tests across 3,000+ browser and OS combinations, and mobile app flows run on 50,000+ real Android and iOS devices.
- API checks inside UI flows - KaneAI tests APIs alongside UI flows in the same run and can generate tests from live database queries, written as plain-English steps.
- Failure triage - Test Intelligence flags flaky tests ranked by flake rate, groups failures by error message, and splits product bugs from test and environment issues.
A background service is reachable only from its own VM, so a job split across five VMs starts five copies of the stub. A Testcontainers suite also needs a Docker-compatible runtime on whichever machine runs it, so confirm that before moving one onto any cloud runner; the run in this guide starts WireMock from its JAR, which needs only Java.
12. VectorCAST
VectorCAST is Vector's embedded software testing platform for unit, integration, and coverage testing in C, C++, and Ada. Several units can be tested together in one environment, with each dependency either stubbed or linked in as real code, so an embedded integration test grows out of the unit tests around it.
- Host, simulator, or target - tests written on the host re-run on a simulator or the embedded board without a rewrite.
- Certification evidence - statement, branch, and MC/DC coverage reports for programs under DO-178C, ISO 26262, IEC 61508, IEC 62304, and EN 50716.
- Continuous testing - VectorCAST/QA plugs into Jenkins, spreads tests across a farm of test machines, and reruns only the tests a code change affects.
Evaluations run through Vector's sales specialists, tool qualification packages are sold separately, and no pricing is published. For web services it is the wrong tool; for flight, vehicle, or medical firmware, its coverage reports are built for certification review.
13. LDRA
LDRA has spent 50 years building verification tools for critical software, and TASKING announced its acquisition of the company in February 2025. In the LDRA tool suite, TBrun automates the generation, execution, and management of unit and integration tests on host or target hardware, including the test harness, test vectors, and code stubs.
- Requirements traceability - TBmanager links requirements, design, source code, test cases, and verification results, the chain a certification audit follows.
- Standards - DO-178C, ISO 26262, IEC 61508, IEC 62304, and EN 50716, plus MISRA C and C++ checks through TBmisra.
- Embedded CI - runs inside Jenkins and GitLab CI pipelines.
On-target testing needs a separate Target Licence Package for each toolchain and target, so plan for one per board family; LDRA offers a free 30-day trial. TESSY from Razorcat is a third option in this niche, qualified for IEC 61508, IEC 62304, ISO 26262, and EN 50128.
Austin Siewert
Co-Founder, Steadfast Systems
Discovered @TestMu AI yesterday. Best browser testing tool I've found for my use case. Great pricing model for the limited testing I do 👏
3M+ Devs and QAs rely on TestMu AI
Deliver immersive digital experiences with Next-Generation Mobile Apps and Cross Browser Testing Cloud
Which Integration Testing Framework Fits Your Language?
A test runner hosts integration tests, and the tools above supply the real dependencies, the stubs, and the assertions. Each ecosystem documents its own combination, and adding one rarely means changing the runner.
| Language | Test runner | Real dependencies | HTTP stubs and mocks |
|---|---|---|---|
| Java | JUnit 6 (Jupiter) with Spring Boot's @SpringBootTest | Testcontainers, wired into the app through @ServiceConnection | WireMock, with REST Assured for assertions |
| C# and .NET | xUnit, NUnit, or MSTest with WebApplicationFactory<TEntryPoint> | Testcontainers for .NET | WireMock.Net |
| Python | pytest, with fixtures managing each dependency | testcontainers-python | WireMock standalone, as in the run below |
| JavaScript and Node.js | Jest or Vitest, with Supertest for HTTP assertions | Testcontainers for Node.js | Mock Service Worker |
| Go | go test with net/http/httptest | Testcontainers for Go | httptest test servers |
Spring Boot's Testcontainers support connects containers to the application through @ServiceConnection, so the test carries no hand-written connection settings. On .NET, Microsoft's guide to ASP.NET Core integration tests builds an in-memory test server from WebApplicationFactory. For a step-by-step Python version with pytest, see Python integration testing.
How Do You Choose an Integration Testing Tool?
Start from the failure you want to catch, not from the tool. Each row below maps a failure that unit tests miss to the tool built to expose it.
| Failure you want to catch | Start with | Why |
|---|---|---|
| SQL, migration, or driver bugs that only appear on the real database | Testcontainers | Runs the actual database version in a throwaway container for each run |
| A request chain that breaks across endpoints, such as create then read | Postman, REST Assured, or Karate | Chains real HTTP calls and asserts on every response |
| Your code mishandling a third-party outage, error, or slow response | WireMock | Returns the status codes and delays you script, on demand |
| A provider renaming or removing a field a consumer reads | Pact | Verifies the provider against the consumer's recorded contract before deploy |
| Lost or malformed messages between services on Kafka or JMS | Citrus | Sends and receives on the broker and validates each payload |
| MQ or mainframe integrations you cannot start in a container | IBM DevOps Test Integrations and APIs | Tests and virtualizes enterprise middleware and z/OS applications |
| The UI showing data the backend never sent | Playwright | Checks the page and the server-side state in the same test |
| An integration suite too slow to run on every pull request | TestMu AI HyperExecute | Runs suites on parallel cloud VMs and starts stubs as background services |
| Certification evidence for safety-critical C or C++ | VectorCAST or LDRA | Unit and integration tests with coverage reports built for certification review |
Stubs, contracts, and real dependencies answer different questions. A WireMock stub proves your code handles the responses you scripted, but it cannot tell you when the real provider changes; a Pact contract catches that drift, and a Testcontainers database catches SQL that only fails against the real engine. A practical stack takes one tool from each of those groups and keeps slow UI-level checks for the few flows where the browser itself matters.
How to Run Integration Tests With a Mock Service on HyperExecute
The code under test is a shipping-quote client. It asks a carrier's rates API for a price and falls back to a flat rate when the carrier fails or answers too slowly, which is the branch unit tests usually mock away. Here is shipping/quote.py:
import os
import requests
RATES_URL = os.environ.get("RATES_URL", "http://localhost:8080")
FLAT_RATE_CENTS = 999 # used when the carrier API is down or slow
def shipping_quote(zip_code, weight_g, timeout=2.0):
try:
resp = requests.get(f"{RATES_URL}/v1/rates", timeout=timeout,
params={"zip": zip_code, "weight": weight_g})
except requests.Timeout:
return {"cents": FLAT_RATE_CENTS, "source": "fallback-timeout"}
if resp.status_code >= 500:
return {"cents": FLAT_RATE_CENTS, "source": "fallback-5xx"}
resp.raise_for_status()
body = resp.json()
return {"cents": body["amount_cents"], "source": body["carrier"]}WireMock plays the carrier. Each JSON mapping matches one ZIP code: 10001 returns a price, 99999 returns a 503, and 88888 returns the price after a three-second delay, longer than the client's two-second timeout. This is the slow one, wiremock/mappings/rates-slow.json:
{
"request": {
"method": "GET",
"urlPath": "/v1/rates",
"queryParameters": { "zip": { "equalTo": "88888" } }
},
"response": {
"status": 200,
"fixedDelayMilliseconds": 3000,
"headers": { "Content-Type": "application/json" },
"jsonBody": { "carrier": "ups", "amount_cents": 1450 }
}
}The tests in tests/test_quote.py call the real client over HTTP. The second one asks WireMock's admin API whether the request arrived with the right ZIP code and weight:
# tests/test_quote.py, part 1 of 2
import time
import requests
from shipping.quote import RATES_URL, shipping_quote
def test_quote_uses_carrier_price():
assert shipping_quote("10001", 1200) == {"cents": 1450, "source": "ups"}
def test_stub_saw_zip_and_weight():
shipping_quote("10001", 1200)
q = {"zip": {"equalTo": "10001"}, "weight": {"equalTo": "1200"}}
body = {"method": "GET", "urlPath": "/v1/rates", "queryParameters": q}
seen = requests.post(f"{RATES_URL}/__admin/requests/count", json=body)
assert seen.json()["count"] >= 1# tests/test_quote.py, part 2 of 2
def test_carrier_503_falls_back_to_flat_rate():
assert shipping_quote("99999", 1200)["source"] == "fallback-5xx"
def test_slow_carrier_times_out_to_flat_rate():
start = time.monotonic()
assert shipping_quote("88888", 1200)["source"] == "fallback-timeout"
assert time.monotonic() - start < 2.5HyperExecute installs Python 3.10 and Java 17, starts WireMock as a background service on the same VM, and runs pytest. I used a Windows VM, where the background command runs through PowerShell, so the launcher is a short script, start-wiremock.ps1, that downloads the WireMock 3.13.2 JAR and starts it on port 8080:
param([string]$root = "wiremock")
$base = "https://repo1.maven.org/maven2/org/wiremock/wiremock-standalone"
$jar = "$base/3.13.2/wiremock-standalone-3.13.2.jar"
Invoke-WebRequest -Uri $jar -OutFile wiremock.jar -UseBasicParsing
java -jar wiremock.jar --port 8080 --root-dir $root --disable-bannerversion: 0.1
runson: win
matrix: { suite: ["shipping-quote"] }
runtime:
- { language: python, version: "3.10" }
- { language: java, version: "17" }
backgroundDirectives:
shell: powershell
commands:
- name: wiremock
command: powershell -ep Bypass -File start-wiremock.ps1 wiremock
pre:
- pip install -r requirements.txt
testSuites:
- python -m pytest tests -v -s --junitxml=reports/junit.xml
scenarioCommandStatusOnly: true
uploadArtefacts:
- { name: reports, path: ["reports/**"] }A fixture in tests/conftest.py polls WireMock's admin URL until it answers, because the background service starts alongside the pre stage and may still be downloading its JAR when the tests begin. With LT_USERNAME and LT_ACCESS_KEY exported, one CLI command dispatches the job and downloads the logs:
export CI=true
export LT_USERNAME="<your username>" LT_ACCESS_KEY="<your access key>"
./hyperexecute.exe --config hyperexecute-win.yaml --download-logs \
--download-artifacts --download-artifacts-path dl-greenThis slice of the pytest log comes from job d17f8bca, run on October 13, 2026, with Python 3.10.11 and pytest 9.1.1 on the VM:
collecting ... collected 4 items
tests/test_quote.py::test_quote_uses_carrier_price
WireMock ready after 11.2 s
PASSED
tests/test_quote.py::test_stub_saw_zip_and_weight PASSED
tests/test_quote.py::test_carrier_503_falls_back_to_flat_rate PASSED
tests/test_quote.py::test_slow_carrier_times_out_to_flat_rate PASSEDpytest closed with "4 passed in 13.29s", and the CLI reported the job COMPLETED and exited with code 0. What the run showed:
- Startup cost - WireMock answered 11.2 seconds after the fixture started polling, and pytest counts that wait against the first test. HyperExecute reported a job duration of 45 seconds.
- Fallbacks proven - the 503 case returned the flat rate in 0.006 seconds, and the slow case gave up at 2.003 seconds, on the client's timeout, instead of waiting out the three-second delay.
- Request checked - the admin API confirmed that the stub received the ZIP code and weight the client was given, so the suite checks what the client sent as well as what it received.
Then I changed the stub the way a carrier might change its API: the 10001 mapping in a wiremock-drift folder renames amount_cents to amount and sends dollars instead of cents. The same suite, pointed at that folder in job 3643ce20, failed at the line that reads the price:
> return {"cents": body["amount_cents"], "source": body["carrier"]}
E KeyError: 'amount_cents'
shipping\quote.py:17: KeyErrorpytest reported "2 failed, 2 passed in 23.88s": both tests that ask for ZIP 10001 failed, while the 503 and timeout tests still passed. HyperExecute marked the task failed with the remark "Job failed as encountered a Test level failure", and the CLI printed "Error: Failed tasks found." and exited with code 1, which is what stops a pipeline.
What made the break visible was my edit to the stub. If the real carrier renamed that field, this suite would stay green against the old stub, and Pact's provider verification is the check that closes that gap.
Note: Run your own integration suite, stubs included, on just-in-time cloud VMs. Start free with TestMu AI and point the HyperExecute CLI at a YAML file like the one above.
Conclusion
Pick the integration boundary that broke most recently in staging or production, and add one test for it this sprint with the matching integration testing tool from the decision table. Then run that suite on every pull request: on TestMu AI HyperExecute, the YAML file above and the HyperExecute getting started guide are enough to dispatch a first job.
Testing web or mobile apps without writing code? KaneAI by TestMu AI turns plain-English instructions into tests.
Author
Japneet Singh Chawla is an Engineering Manager at TestMu AI, where he leads a team driving HyperExecute, the AI-native Test Orchestration Cloud Platform, and integrations with Cypress, Provar, Tosca, and Selenium, improving test execution efficiency and driving adoption across 500+ enterprise clients. He also spearheaded zero-downtime deployments that cut release-related downtime by 90%, and mentors new engineers into productive contributors. He brings 9+ years of experience building and scaling distributed systems, SaaS platforms, and developer tools, with deep hands-on backend engineering across Golang, Python, Node.js, Kafka, and Redis. Earlier at Sumo Logic he built award-winning developer tools, including a VS Code Parser Linter, and at Indus Valley Partners he was a founding member of the Sentiment Analyzer team, building ML-powered solutions for financial clients. Japneet holds an MCA in Computer Science from GGSIPU.
Reviewer
Saurabh Prakash is an Engineering Manager at TestMu AI, where he leads engineering on agentic AI development and scalable system architecture for the quality engineering platform. He has also contributed to Test at Scale, the company's open-source test intelligence platform. He brings over 9 years of experience across Node.js, Java, Spring, MVC, data structures, algorithms, and scalable system design, with earlier roles as SDE 2 at Zomato, Senior Software Engineer at LogicHub, and Software Development Engineer at Directi. Saurabh holds a B.Tech in Computer Science and Engineering from Delhi Technological University.
Integration Testing Tools FAQs
Did you find this page helpful?
More Related Blogs
TestMu AI forEnterprise
Get access to solutions built on Enterprise
grade security, privacy, & compliance
- Advanced access controls
- Advanced data retention rules
- Advanced Local Testing
- Premium Support options
- Early access to beta features
- Private Slack Channel
- Unlimited Manual Accessibility DevTools Tests


















