When developing applications that rely on external APIs, testing can become a challenge. You want your tests to be reliable, fast, and not dependent on the availability or performance of third-party services. Enter go-vcr, a fantastic tool that makes HTTP/HTTPS testing straightforward and efficient. In this blog post, we’ll explore what go-vcr is, why you should use it, and how it works.

What is go-vcr ?

go-vcr is a library for the Go programming language that records HTTP interactions and replays them during future test runs. Inspired by Ruby’s vcr gem, go-vcr stands for “Go Video Cassette Recorder”. It essentially acts as a “cassette recorder” for HTTP requests and responses, allowing you to save these interactions and replay them later.

Key Features:

Record and Replay: Capture HTTP interactions and replay them during tests.
Cassette Files: Store interactions in “cassette” files (YAML format) for easy management.
Deterministic Testing: Ensure your tests are not affected by external API changes or downtime.

Why Use go-vcr?

Testing HTTP interactions in your applications can be problematic for several reasons. Here’s why go-vcr is a valuable tool for any Go developer:

Reliability:
Third-party APIs can be unreliable. They may have downtime, rate limits, or return inconsistent data. By using go-vcr, you ensure your tests are not dependent on the availability or performance of these services.

Speed:
Network requests can slow down your tests. When running a suite of tests, especially in CI/CD pipelines, speed is crucial. go-vcr speeds up tests by using recorded responses instead of making actual HTTP requests.
Consistency:
APIs can return different results over time due to data changes. With go-vcr, you get consistent responses, which helps in creating reliable and repeatable tests.
Offline Testing:
With recorded responses, you can run your tests even when you are offline, making development more flexible.

How Does go-vcr Work?

essential, override your transport which is a implematation of RoundTripper func. such as:

1
2
3

client := &http.Client{
        Transport: r, // Use recorder as the transport layer
    }

RoundTripper is an interface that defines the mechanism for making a single HTTP transaction, which consists of a request and a response. You can implement your own RoundTrip function by your custom logic. go-vcr implements its own RoundTrip to record your http/https requests and replay your http/https requests.

If your http client need use mTLS, please see this example:
https://github.com/shufanhao/go-example/blob/6ca68c0ead2a660e233db2ed973561743ea7331d/vcr/vcr_test.go#L63

How Integrate into your Testing

Using go-vcr involves a few simple steps: installing the package, setting up the recorder, recording HTTP interactions, and replaying them. Let’s dive into each step.

package main

import (
    "net/http"
    "github.com/dnaeon/go-vcr/v2/recorder"
)

func main() {
    // Start a new recorder
    r, err := recorder.New("fixtures/cassette")
    if err != nil {
        panic(err)
    }
    defer r.Stop() // Ensure recorder is stopped when done

    // Create an HTTP client and inject the recorder transport
    client := &http.Client{
        Transport: r, // Use recorder as the transport layer
    }

    // Make an HTTP request
    resp, err := client.Get("http://example.com")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    // Process the response...
}

Conclusion

go-vcr is a powerful tool that simplifies the testing of HTTP/HTTPS interactions in Go applications. By recording and replaying HTTP requests, it makes your tests faster, more reliable, and less dependent on external services. Whether you’re dealing with unreliable APIs, aiming to speed up your test suite, or looking to save costs, go-vcr can help you achieve your goals. Give it a try and experience the magic of reliable HTTP testing!