为 gcp 计算 sdk 创建一个模拟

来到golang学习网的大家，相信都是编程学习爱好者，希望在这里学习Golang相关编程知识。下面本篇文章就来带大家聊聊《为 gcp 计算 sdk 创建一个模拟》，介绍一下，希望对大家的知识积累有所帮助，助力实战开发！

我使用以下函数，并且我需要提高它的覆盖率（如果可能的话达到100%），问题是我通常使用 interface 来处理 go 中的此类情况，为此具体情况不知道该怎么做，因为这有点棘手，有什么想法吗？

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

我使用的没有 interface 所以不确定如何模拟它？

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
}

正确答案

这里可测试性的一个障碍是您在 res 函数中实例化客户端而不是注入它。因为

• 这个秘密在程序的生命周期内不会改变，
• *compute.addressesclient（clos​​e 除外）的方法是并发安全的，

您可以创建一个客户端并为每次调用或 res 重用它。要将其注入到 res 中，您可以声明一些 compute 类型并将 res 转换为该类型的方法：

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
}

仍然存在一个问题：您应该如何声明 lister？一种可能性是

type lister interface {
    list(ctx context.context, req *computev1.listaddressesrequest, opts ...gax.calloption) *compute.addressiterator
}

但是，由于 compute.addressiterator 是一个具有一些未导出字段的结构类型，并且 compute 包没有提供工厂函数，因此您无法轻松控制从 list 返回的迭代器在测试中的行为方式。一种解决方法是声明一个附加接口，

type iterator interface {
    next() (*computev1.address, error)
}

并将 list 的结果类型从 *compute.addressiterator 更改为 iterator：

type lister interface {
    list(ctx context.context, req *computev1.listaddressesrequest, opts ...gax.calloption) iterator
}

然后您可以为真正的 lister 声明另一个结构类型并在生产端使用它：

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
    }
}

对于您的测试，您可以声明另一个结构类型，它将充当可配置的测试替身：

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...)
}

要控制测试中 iterator 的行为，您可以声明另一个可配置的具体类型：

type fakeiterator struct{
    err error
    status string
}

func (fi *fakeiterator) next() (*computev1.address, error) {
    addr := computev1.address{status: &fi.status}
    return &addr, fi.err
}

测试函数可能如下所示：

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 {
        // ...
    }
}

每当我发现自己处于这种情况时，我发现最简单的解决方案就是自己创建缺失接口。我将这些接口限制为我正在使用的类型和函数，而不是为整个库编写接口。然后，在我的代码中，我不接受第三方具体类型，而是接受这些类型的接口。然后我像往常一样使用 gomock 为这些接口生成模拟。

以下是受您的代码启发的描述性示例。

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
}

现在，您可以通过将模拟 restclient 注入到内部 res 函数来测试 res 函数的重要部分。

今天带大家了解了的相关知识，希望对你有所帮助；关于Golang的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~