Go create a mock for gcp compute sdk

Question

I use the following function, and I need to raise the coverage of it (if possible to 100%), the problem is that typically I use interface to handle such cases in Go and for this specific case not sure how to do it, as this is a bit more tricky, any idea?

The package https://pkg.go.dev/google.golang.org/genproto/googleapis/cloud/compute/v1

Which I use doesn't have interface so not sure how can I mock it?

import (
    "context"
    "errors"
    "fmt"
    "os"

    compute "cloud.google.com/go/compute/apiv1"
    "google.golang.org/api/iterator"
    "google.golang.org/api/option"
    computev1 "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

func Res(ctx context.Context, project string, region string,vpc string,secret string) error {

    c, err := compute.NewAddressesRESTClient(ctx, option.WithCredentialsFile(secret))

    if err != nil {
        return err
    }

    defer c.Close()
    addrReq := &computev1.ListAddressesRequest{
        Project: project,
        Region:  region,
    }
    it := c.List(ctx, addrReq)

    for {
        resp, err := it.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            return err
        }
        if *(resp.Status) != "IN_USE" {
            return ipConverter(*resp.Name, vpc)
        }
    }
    return nil
}

Answer 1

One obstacle to testability here is that you instantiate a client inside your Res function rather than injecting it. Because

• the secret doesn't change during the lifetime of the programme,
• the methods of *compute.AddressesClient (other than Close) are concurrency-safe,

you could create one client and reuse it for each invocation or Res. To inject it into Res, you can declare some Compute type and turn Res into a method on that type:

type Compute struct {
  Lister Lister // some appropriate interface type
}

func (cp *Compute) Res(ctx context.Context, project, region, vpc string) error {
addrReq := &computev1.ListAddressesRequest{
        Project: project,
        Region:  region,
    }
    it := cp.Lister.List(ctx, addrReq)
    for {
        resp, err := it.Next()
        if err == iterator.Done {
            break
        }
        if err != nil {
            return err
        }
        if *(resp.Status) != "IN_USE" {
            return ipConverter(*resp.Name, vpc)
        }
    }
    return nil
}

One question remains: how should you declare Lister? One possibility is

type Lister interface {
    List(ctx context.Context, req *computev1.ListAddressesRequest, opts ...gax.CallOption) *compute.AddressIterator
}

However, because compute.AddressIterator is a struct type with some unexported fields and for which package compute provides no factory function, you can't easily control how the iterator returned from List behaves in your tests. One way out is to declare an additional interface,

type Iterator interface {
    Next() (*computev1.Address, error)
}

and change the result type of List from *compute.AddressIterator to Iterator:

type Lister interface {
    List(ctx context.Context, req *computev1.ListAddressesRequest, opts ...gax.CallOption) Iterator
}

Then you can declare another struct type for the real Lister and use that on the production side:

type RealLister struct {
    Client *compute.AddressesClient
}

func (rl *RealLister) List(ctx context.Context, req *computev1.ListAddressesRequest, opts ...gax.CallOption) Iterator {
    return rl.Client.List(ctx, req, opts...)
}

func main() {
    secret := "don't hardcode me"
    ctx, cancel := context.WithCancel(context.Background()) // for instance
    defer cancel()
    c, err := compute.NewAddressesRESTClient(ctx, option.WithCredentialsFile(secret))
    if err != nil {
        log.Fatal(err) // or deal with the error in some way
    }
    defer c.Close()
    cp := Compute{Lister: &RealLister{Client: c}}
    if err := cp.Res(ctx, "my-project", "us-east-1", "my-vpc"); err != nil {
        log.Fatal(err) // or deal with the error in some way
    }
}

For your tests, you can declare another struct type that will act as a configurable test double:

type FakeLister func(ctx context.Context, req *computev1.ListAddressesRequest, opts ...gax.CallOption) Iterator

func (fl FakeLister) List(ctx context.Context, req *computev1.ListAddressesRequest, opts ...gax.CallOption) Iterator {
    return fl(ctx, req, opts...)
}

To control the behaviour of the Iterator in your test, you can declare another configurable concrete type:

type FakeIterator struct{
    Err error
    Status string
}

func (fi *FakeIterator) Next() (*computev1.Address, error) {
    addr := computev1.Address{Status: &fi.Status}
    return &addr, fi.Err
}

A test function may look like this:

func TestResStatusInUse(t *testing.T) {
    // Arrange
    l := func(_ context.Context, _ *computev1.ListAddressesRequest, _ ...gax.CallOption) Iterator {
        return &FakeIterator{
            Status: "IN_USE",
            Err:    nil,
        }
    }
    cp := Compute{Lister: FakeLister(l)}
    dummyCtx := context.Background()
    // Act
    err := cp.Res(dummyCtx, "my-project", "us-east-1", "my-vpc")
    // Assert
    if err != nil {
        // ...
    }
}

Answer 2

Whenever I find myself in this scenario, I found that the easiest solution is to create missing interfaces myself. I limit these interfaces to the types and functions that I am using, instead of writing interfaces for the entire library. Then, in my code, instead of accepting third-party concrete types, I accept my interfaces for those types. Then I use gomock to generate mocks for these interfaces as usual.

The following is a descriptive example inspired by your code.

type RestClient interface {
    List(context.Context, *computev1.ListAddressesRequest) (ListResult, error) // assuming List returns ListResult type.
    Close() error
}

func newRestClient(ctx context.Context, secret string) (RestClient, error) {
    return compute.NewAddressesRESTClient(ctx, option.WithCredentialsFile(secret))
}

func Res(ctx context.Context, project string, region string, vpc string, secret string) error {
    c, err := newRestClient(ctx, secret)
    if err != nil {
        return err
    }

    defer c.Close()
    return res(ctx, project, region, vpc, c)
}

func res(ctx context.Context, project string, region string, vpc string, c RestClient) error {
    addrReq := &computev1.ListAddressesRequest{
        Project: project,
        Region:  region,
    }

    it, err := c.List(ctx, addrReq)
    if err != nil {
        return err
    }

    for {
        resp, err := it.Next()
        if err == iterator.Done {
            break
        }

        if err != nil {
            return err
        }

        if *(resp.Status) != "IN_USE" {
            return ipConverter(*resp.Name, vpc)
        }
    }

    return nil
}

Now you can test the important bits of the Res function by injecting a mock RestClient to the internal res function.