Google APIs Client Library for Go

Since google.golang.org/api services are HTTP-based and return concrete types rather than interfaces, you can test your code by serving an in-memory server using the standard library's httptest package.

To redirect the client to your fake server instead of the live Google API, use option.WithEndpoint(ts.URL) when calling the service constructor. It is also recommended to use option.WithoutAuthentication() in your tests to avoid credential issues when hitting a local fake server.

import (
    "context"
    "encoding/json"
    "net/http"
    "net/http/httptest"
    "testing"

    "google.golang.org/api/option"
    "google.golang.org/api/translate/v3"
)

func TestTranslateText(t *testing.T) {
    ctx := context.Background()
    // 1. Create the fake server
    ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        resp := &translate.TranslateTextResponse{
            Translations: []*translate.Translation{
                {TranslatedText: "Hello World"},
            },
        }
        b, err := json.Marshal(resp)
        if err != nil {
            http.Error(w, "unable to marshal request: "+err.Error(), http.StatusBadRequest)
            return
        }
        w.Write(b)
    }))
    defer ts.Close()

    // 2. Initialize the service pointing to the fake endpoint
    svc, err := translate.NewService(ctx, option.WithoutAuthentication(), option.WithEndpoint(ts.URL))
    if err != nil {
        t.Fatalf("unable to create client: %v", err)
    }

    // 3. Call your production code
    text, err := TranslateText(svc, "Hola Mundo", "en-US")
    if err != nil {
        t.Fatal(err)
    }
    if text != "Hello World" {
        t.Fatalf("got %q, want Hello World", text)
    }
}

The client libraries in google.golang.org/api use a builder pattern for requests, which makes creating low-level interfaces for mocking difficult and tedious.

Instead, use the Facade pattern:

1. Define a high-level interface that represents the specific business logic you need (e.g., TranslateText(text, language string)).
2. Create a concrete wrapper struct that holds the actual *service.Service and implements your interface by calling the complex builder methods.
3. In your tests, pass a lightweight mock implementation of your high-level interface instead of the real service.

// 1. Define a high-level interface (The Facade)
type TranslateService interface {
    TranslateText(text, language string) (string, error)
}

// 2. Create a wrapper for production use
type translateService struct {
    svc *translate.Service
}

func (t *translateService) TranslateText(text, language string) (string, error) {
    parent := fmt.Sprintf("projects/%s/locations/global", os.Getenv("GOOGLE_CLOUD_PROJECT"))
    resp, err := t.svc.Projects.Locations.TranslateText(parent, &translate.TranslateTextRequest{
        TargetLanguageCode: language,
        Contents:           []string{text},
    }).Do()
    if err != nil {
        return "", err
    }
    return resp.Translations[0].TranslatedText, nil
}

// 3. Create a mock for testing
type mockService struct{}

func (*mockService) TranslateText(text, language string) (string, error) {
    return "Hello World", nil
}

func TestTranslateTextHighLevel(t *testing.T) {
    svc := &mockService{}
    text, err := TranslateTextHighLevel(svc, "Hola Mundo", "en-US")
    // ... assert results
}