我认为您正在寻找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(context.Context, string) (net.Conn, error) {
    return lis.Dial()
}

func TestSayHello(t *testing.T) {
    ctx := context.Background()
    conn, err := grpc.DialContext(ctx, "bufnet", grpc.WithContextDialer(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.
}

这种方法的好处是，你仍然可以获得网络行为，但通过内存连接，而不需要使用操作系统级别的资源，如端口，这些资源可能会也可能不会很快清理干净。它允许你以实际使用的方式测试它，并为你提供正确的流行为。
我并没有一个流媒体的例子，但是它的神奇之酱料就在上面。它提供了一个正常网络连接的所有预期行为。诀窍是设置WithDialer选项，如图所示，使用bufconn包创建一个监听器，它公开了自己的拨号器。我一直在使用这种技术来测试gRPC服务，效果很好。

如果您想验证gRPC服务的实现是否如您所期望的那样，那么您可以只编写标准单元测试并完全忽略网络。
例如，使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)
        }
    }
}

我可能在记忆中把proto语法弄得有点乱，但这就是我的想法。

这里可能是一个简单的方法只是测试流媒体服务。抱歉，如果有任何错字的，因为我改编了一些运行代码。
给定以下定义。

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中，然后您可以在assert陈述式中使用。
最后，使用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服务而烦恼。

我提出了下面的实现，但这可能不是最好的实现方式。主要是使用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)
        }

    })
}

测试gRPC服务的方法有很多种。您可以选择不同的测试方法，这取决于您希望获得的可靠性。下面是三个示例，说明一些常见的情况。

Case #1：我想测试我的业务逻辑

在这种情况下，您感兴趣的是服务中的逻辑以及它如何与其他组件交互。
Alex Ellis有一个很好的introduction to unit testing in Go。如果你需要测试交互，那么GoMock是一个很好的方法。Sergey Grebenshchikov写了一个很好的GoMock tutorial。
Omar给出的答案显示了如何对这个特定的SayHello示例进行单元测试。

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

在这种情况下，您希望手动对API进行探索性测试。通常，这样做是为了探索实现，检查边缘情况，并确信API的行为符合预期。
您需要：
1.启动gRPC服务器
1.使用网络模拟解决方案来模拟您拥有的任何依赖项，例如，如果您的gRPC服务在测试中对另一个服务进行gRPC调用。例如，您可以使用Traffic Parrot。
1.使用gRPC API测试工具。例如，您可以使用gRPC CLI。
现在，您可以使用模拟解决方案来模拟真实的和假设的情况，同时通过使用API测试工具来观察被测服务的行为。

案例#3：我希望通过网络自动测试我的API

在这种情况下，您对编写自动化的BDD风格的验收测试感兴趣，这些测试通过有线gRPC API与被测系统交互。这些测试的编写、运行和维护成本很高，应该谨慎使用，记住testing pyramid。
thinkerou的答案展示了如何使用karate-grpc用Java编写这些API测试。您可以将其与Traffic Parrot Maven插件结合使用来模拟任何跨线依赖。

顺便说一句：作为一个新的贡献者，我不能添加到评论。所以我在这里添加一个新的答案。
我可以确认，通过在没有运行服务的情况下通过接口进行测试，@Omar方法适用于测试非流式gRPC服务。
但是这种方法对流不起作用，因为gRPC支持双向流，所以需要启动服务并通过网络层连接到它来测试流。
joscas采用的方法适用于gRPC流（尽管helloworld示例代码没有使用流）使用goroutine来启动服务，但是我注意到在MacOSX10.11.6上，当从goroutine调用服务时，它并没有释放服务所使用的端口（据我所知，这个服务会阻塞goroutine，而且可能不会干净地退出）通过启动一个单独的进程让服务在其中运行，使用'exec. command'，并在完成之前杀死它，端口始终被释放。
我使用流将gRPC服务的工作测试文件上传到github：https://github.com/mmcc007/go/blob/master/examples/route_guide/server/server_test.go
您可以看到Travis上运行的测试：https://travis-ci.org/mmcc007/go
请让我知道，如果任何建议，如何改善测试的gRPC服务。

作为一个新的贡献者，我不能发表评论，所以我在这里添加作为一个答案。
@shiblon的答案是测试你的服务的最好方法。我是 * grpc-for-production * 的维护者，其中一个特性是一个正在处理的服务器，这使得使用bufconn更容易。
下面是一个测试迎宾服务的示例

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

您可以使用karate-grpc来测试grpc服务，您只需要发布您proto jar和grpc服务器ip/port.karate-grpc构建（基于空手道和多语制）。
一个地狱世界的例子：

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/