案例1：我想测试我的业务逻辑

Question

我想测试用Go编写的gRPC服务。我使用的示例是grpc-go repo中的Hello World服务器示例。

protobuf定义如下：

syntax = "proto3";

package helloworld;

// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

greeter_server主要的类型是：

// server is used to implement helloworld.GreeterServer.
type server struct{}

// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

我已经查找过示例，但我找不到如何在Go中为gRPC服务实现测试。

Answer 1

如果您想验证gRPC服务的实现是否符合预期，那么您只需编写标准单元测试并完全忽略网络。

例如，make greeter_server_test.go：

func HelloTest(t *testing.T) {
    s := server{}

    // set up test cases
    tests := []struct{
        name string
        want string
    } {
        {
            name: "world",
            want: "Hello world",
        },
        {
            name: "123",
            want: "Hello 123",
        },
    }

    for _, tt := range tests {
        req := &pb.HelloRequest{Name: tt.name}
        resp, err := s.SayHello(context.Background(), req)
        if err != nil {
            t.Errorf("HelloTest(%v) got unexpected error")
        }
        if resp.Message != tt.want {
            t.Errorf("HelloText(%v)=%v, wanted %v", tt.name, resp.Message, tt.want)
        }
    }
}

我可能已经从内存中弄乱了原始语法，但这就是想法。

Answer 2

我认为您正在寻找google.golang.org/grpc/test/bufconn软件包，以帮助您避免使用真实端口号启动服务，但仍允许测试流式RPC。

import "google.golang.org/grpc/test/bufconn"

const bufSize = 1024 * 1024

var lis *bufconn.Listener

func init() {
    lis = bufconn.Listen(bufSize)
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    go func() {
        if err := s.Serve(lis); err != nil {
            log.Fatalf("Server exited with error: %v", err)
        }
    }()
}

func bufDialer(string, time.Duration) (net.Conn, error) {
    return lis.Dial()
}

func TestSayHello(t *testing.T) {
    ctx := context.Background()
    conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithDialer(bufDialer), grpc.WithInsecure())
    if err != nil {
        t.Fatalf("Failed to dial bufnet: %v", err)
    }
    defer conn.Close()
    client := pb.NewGreeterClient(conn)
    resp, err := client.SayHello(ctx, &pb.HelloRequest{"Dr. Seuss"})
    if err != nil {
        t.Fatalf("SayHello failed: %v", err)
    }
    log.Printf("Response: %+v", resp)
    // Test for output here.
}

此方法的优点是，您仍然会出现网络行为，但是通过内存连接而不使用操作系统级别的资源（如可能会很快清除或可能不会很快清除的端口）。而且它允许您以实际使用的方式对其进行测试，并为您提供适当的流式传输行为。

我的头上没有流式传输示例，但魔术酱却在上面。它为您提供了正常网络连接的所有预期行为。技巧是使用bufconn包来设置所示的WithDialer选项，以使用暴露自己的拨号程序的侦听器。我一直在使用这种技术来测试gRPC服务，并且效果很好。

Answer 3

我想出了以下实现，这可能不是最好的方法。主要使用TestMain函数使用 goroutine 来启动服务器：

const (
    port = ":50051"
)

func Server() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}
func TestMain(m *testing.M) {
    go Server()
    os.Exit(m.Run())
}

然后在其余测试中实现客户端：

func TestMessages(t *testing.T) {

    // Set up a connection to the Server.
    const address = "localhost:50051"
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        t.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    // Test SayHello
    t.Run("SayHello", func(t *testing.T) {
        name := "world"
        r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
        if err != nil {
            t.Fatalf("could not greet: %v", err)
        }
        t.Logf("Greeting: %s", r.Message)
        if r.Message != "Hello "+name {
            t.Error("Expected 'Hello world', got ", r.Message)
        }

    })
}

Answer 4

这可能只是一种测试流媒体服务的简单方法。如果有任何拼写错误，我会道歉，因为我正在调整一些正在运行的代码。

给出以下定义。

rpc ListSites(Filter) returns(stream sites)

使用以下服务器端代码。

// ListSites ...
func (s *SitesService) ListSites(filter *pb.SiteFilter, stream pb.SitesService_ListSitesServer) error {
    for _, site := range s.sites {
        if err := stream.Send(site); err != nil {
            return err
        }
    }
    return nil
}

现在您要做的就是在测试文件中模拟 pb.SitesService_ListSitesServer 。

type mockSiteService_ListSitesServer struct {
    grpc.ServerStream
    Results []*pb.Site
}

func (_m *mockSiteService_ListSitesServer) Send(site *pb.Site) error {
    _m.Results = append(_m.Results, site)
    return nil
}

这会响应 .send 事件，并在.Results中记录已发送的对象，然后您可以在断言语句中使用这些对象。

最后，您使用 pb.SitesService_ListSitesServer 的模拟实现来调用服务器代码。

func TestListSites(t *testing.T) {
    s := SiteService.NewSiteService()
    filter := &pb.SiteFilter{}

    mock := &mockSiteService_ListSitesServer{}
    s.ListSites(filter, mock)

    assert.Equal(t, 1, len(mock.Results), "Sites expected to contain 1 item")
}

不，它不会测试整个堆栈，但它确实可以让您理智地检查服务器端代码，而无需以真实或模拟形式运行完整的gRPC服务。

Answer 5

您可以选择多种方式来测试gRPC服务。您可以选择不同的测试方式，具体取决于您希望获得的信任程度。以下三种情况说明了一些常见情况。

案例1：我想测试我的业务逻辑

在这种情况下，您对服务中的逻辑及其与其他组件的交互方式感兴趣。最好的做法是编写一些单元测试。

Alex Ellis有个不错的introduction to unit testing in Go。如果您需要测试互动，那么GoMock是您的最佳选择。谢尔盖·格雷本什基科夫（Sergey Grebenshchikov）写了一个不错的GoMock tutorial。

answer from Omar显示了如何对这个特定的SayHello示例进行单元测试。

案例2：我想通过网络手动测试实时服务的API

在这种情况下，您有兴趣对API进行手动探索性测试。通常，这样做是为了探索实现，检查极端情况并确保您的API行为符合预期。

您将需要：

启动您的gRPC server
使用在线模拟解决方案模拟您具有的任何依赖关系，例如如果您的被测试gRPC服务对另一个服务进行了gRPC调用。例如，您可以使用Traffic Parrot。
使用gRPC API测试工具。例如，您可以使用gRPC CLI。

现在，您可以使用模拟解决方案来模拟真实和假设的情况，同时使用API测试工具来观察被测服务的行为。

案例3：我想自动进行API的线路测试

在这种情况下，您有兴趣编写自动化的BDD样式验收测试，该测试通过在线gRPC API与被测系统进行交互。这些测试的编写，运行和维护都很昂贵，因此请谨慎使用testing pyramid。

answer from thinkerou显示了如何使用karate-grpc用Java编写那些API测试。您可以将其与Traffic Parrot Maven plugin结合使用，以模拟任何在线依赖。

Answer 6

BTW：作为新的撰稿人，我无法添加评论。所以我在这里添加一个新答案。

我可以确认@Omar方法可以通过没有正在运行的服务的接口进行测试来测试非流式gRPC服务。

但是这种方法不适用于流。由于gRPC支持双向流，因此必须启动服务并通过网络层连接到服务，以便对流进行测试。

@joscas采用的方法适用于gRPC流（即使helloworld示例代码不使用流），使用goroutine启动服务。但是，我注意到在Mac OS X 10.11.6上，当从goroutine调用时，它不会一致地释放服务使用的端口（据我所知，该服务将阻止goroutine并且可能不会干净地退出）。通过使用'exec.Command'启动服务运行的单独进程，并在完成之前将其终止，端口将一致地释放。

我使用流向github上传了gRPC服务的工作测试文件：https://github.com/mmcc007/go/blob/master/examples/route_guide/server/server_test.go

您可以看到在travis上运行的测试：https://travis-ci.org/mmcc007/go

如果有任何关于如何改进gRPC服务测试的建议，请告诉我。

Answer 7

作为新的贡献者，我无法发表评论，因此我在此处添加答案。

@shiblon答案是测试服务的最佳方法。我是 grpc-for-production 的维护者，功能之一是一个正在处理的服务器，可以更轻松地使用bufconn。

这里是测试greeter服务的一个示例

var server GrpcInProcessingServer

func serverStart() {
    builder := GrpcInProcessingServerBuilder{}
    builder.SetUnaryInterceptors(util.GetDefaultUnaryServerInterceptors())
    server = builder.Build()
    server.RegisterService(func(server *grpc.Server) {
        helloworld.RegisterGreeterServer(server, &testdata.MockedService{})
    })
    server.Start()
}

//TestSayHello will test the HelloWorld service using A in memory data transfer instead of the normal networking
func TestSayHello(t *testing.T) {
    serverStart()
    ctx := context.Background()
    clientConn, err := GetInProcessingClientConn(ctx, server.GetListener(), []grpc.DialOption{})
    if err != nil {
        t.Fatalf("Failed to dial bufnet: %v", err)
    }
    defer clientConn.Close()
    client := helloworld.NewGreeterClient(clientConn)
    request := &helloworld.HelloRequest{Name: "test"}
    resp, err := client.SayHello(ctx, request)
    if err != nil {
        t.Fatalf("SayHello failed: %v", err)
    }
    server.Cleanup()
    clientConn.Close()
    assert.Equal(t, resp.Message, "This is a mocked service test")
}

您可以找到此示例here

Answer 8

您可以使用karate-grpc测试grpc服务，只需要发布您的原型jar和grpc服务器ip /端口。 karate-grpc基于空手道和多语种构建。

一个hello-world示例：

Feature: grpc helloworld example by grpc dynamic client

  Background:
    * def Client = Java.type('com.github.thinkerou.karate.GrpcClient')
    * def client = Client.create('localhost', 50051)

  Scenario: do it
    * def payload = read('helloworld.json')
    * def response = client.call('helloworld.Greeter/SayHello', payload)
    * def response = JSON.parse(response)
    * print response
    * match response[0].message == 'Hello thinkerou'
    * def message = response[0].message

    * def payload = read('again-helloworld.json')
    * def response = client.call('helloworld.Greeter/AgainSayHello', payload)
    * def response = JSON.parse(response)
    * match response[0].details == 'Details Hello thinkerou in BeiJing'

关于空手道grpc注释的示例：

它将生成漂亮的报告，例如：

更多详细信息，请参见：https://thinkerou.com/karate-grpc/

测试gRPC服务

8 个答案:

案例1：我想测试我的业务逻辑

案例2：我想通过网络手动测试实时服务的API

案例3：我想自动进行API的线路测试