API testing guides — test REST and GraphQL APIs, write contract tests, and automate API validation.
Contract Testing
Specmatic turns your OpenAPI specifications into executable contracts that work from both sides: it can run your spec as a stub server for consumer testing, and verify that your actual API implementation conforms to the spec for provider testing. One spec file, both directions — without writing a single test. The
API Testing
Dredd validates that your API implementation matches its documentation. It reads your API Blueprint or OpenAPI specification, makes real HTTP requests to your running server, and checks that the responses match what the spec promises. When your code and your docs disagree, Dredd fails — forcing you to keep them in
API Testing
API fuzzing finds the bugs that escape manual testing and code review: server crashes from unexpected inputs, schema violations from edge cases, and authorization gaps revealed by unusual request sequences. But fuzzing without a clear strategy wastes time and generates noise. This guide covers the practices that make API fuzzing
Testing
API-first development means writing your OpenAPI specification before writing code. But there's a gap between having a spec and having something to develop against — until you write the API, frontend developers are blocked. Prism closes this gap. Give it an OpenAPI (Swagger) specification and it instantly runs a
Testing
Most API mocking libraries intercept calls at the code level — patching fetch, wrapping axios, or monkey-patching network modules. This approach breaks easily when libraries change internals or when you switch HTTP clients. Mock Service Worker (MSW) takes a different approach. In browsers, it registers an actual service worker that intercepts
Testing
Most API mocking tools only speak HTTP. That's fine for REST APIs, but modern systems include gRPC services, legacy TCP protocols, SMTP servers, and binary protocols that HTTP-only tools can't touch. Mountebank is a service virtualization tool that handles multiple protocols through a unified interface. You
Testing
One of the hardest parts of building integration tests is creating realistic test data. You can write mock responses by hand, but they drift from reality. You can call the real API in tests, but that introduces network dependency and flakiness. Hoverfly solves this with a record-and-replay approach. It runs
Testing
Testing React components that fetch data requires handling asynchronous behavior, loading states, error conditions, and successful renders. The combination of Mock Service Worker (MSW) and React Testing Library gives you a powerful toolkit for writing these tests without mocking at the module level or coupling your tests to implementation details.
Testing
API mocking is one of those techniques that transforms development speed. When backend services are unavailable, slow, or expensive to call in tests, a local mock server lets you develop and test against realistic API responses without any network dependency. Mockoon is the simplest tool available for this job. It&
Protobuf
Protocol Buffers (Protobuf) is not just a serialization format — it's a schema system. When you change a .proto file, you're changing a contract that potentially affects every service that uses it. Testing Protobuf schemas means validating not just that serialization works, but that your changes don&
gRPC
Choosing between gRPC and REST involves architecture trade-offs that extend into your testing stack. The way you test these protocols differs significantly — in tooling, debugging overhead, contract management, and the kind of bugs each approach catches. This comparison focuses on the practical testing reality of each protocol, not just their
gRPC
gRPC services are harder to test than REST APIs. HTTP endpoints accept plain JSON you can curl in seconds; gRPC uses binary Protobuf encoding over HTTP/2 and requires generated client code to send requests. This complexity shows up in your test setup. This guide covers a complete gRPC testing