Add tests for gRPC span duration an Stackdriver gRPC exporting

exporter/stackdriver/stackdriver_test.go

@@ -23,6 +23,7 @@ import (
 	"testing"
 	"time"
 
+	"go.opencensus.io/internal/testpb"
 	"go.opencensus.io/plugin/ochttp"
 	"go.opencensus.io/stats/view"
 	"go.opencensus.io/trace"
@@ -81,3 +82,28 @@ func TestExport(t *testing.T) {
 	exporter.Flush()
 	exporter.Flush()
 }
+
+func TestGrpc(t *testing.T) {
+	projectID, ok := os.LookupEnv("STACKDRIVER_TEST_PROJECT_ID")
+	if !ok {
+		t.Skip("STACKDRIVER_TEST_PROJECT_ID not set")
+	}
+
+	exporter, err := NewExporter(Options{ProjectID: projectID})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer exporter.Flush()
+
+	trace.RegisterExporter(exporter)
+	defer trace.UnregisterExporter(exporter)
+	view.RegisterExporter(exporter)
+	defer view.UnregisterExporter(exporter)
+
+	trace.SetDefaultSampler(trace.AlwaysSample())
+
+	client, done := testpb.NewTestClient(t)
+	defer done()
+
+	client.Single(context.Background(), &testpb.FooRequest{SleepNanos: int64(42 * time.Millisecond)})
+}

internal/testpb/impl.go

@@ -0,0 +1,92 @@
+// Copyright 2018, OpenCensus Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package testpb
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net"
+	"time"
+
+	"go.opencensus.io/plugin/ocgrpc"
+	"go.opencensus.io/trace"
+	"google.golang.org/grpc"
+)
+
+type testServer struct{}
+
+var _ FooServer = (*testServer)(nil)
+
+func (s *testServer) Single(ctx context.Context, in *FooRequest) (*FooResponse, error) {
+	if in.SleepNanos > 0 {
+		_, span := trace.StartSpan(ctx, "testpb.Single.Sleep")
+		span.AddAttributes(trace.Int64Attribute("sleep_nanos", in.SleepNanos))
+		time.Sleep(time.Duration(in.SleepNanos))
+		span.End()
+	}
+	if in.Fail {
+		return nil, fmt.Errorf("request failed")
+	}
+	return &FooResponse{}, nil
+}
+
+func (s *testServer) Multiple(stream Foo_MultipleServer) error {
+	for {
+		in, err := stream.Recv()
+		if err == io.EOF {
+			return nil
+		}
+		if err != nil {
+			return err
+		}
+		if in.Fail {
+			return fmt.Errorf("request failed")
+		}
+		if err := stream.Send(&FooResponse{}); err != nil {
+			return err
+		}
+	}
+}
+
+func NewTestClient(l interface{ Fatal(args ...interface{}) }) (client FooClient, cleanup func()) {
+	// initialize server
+	listener, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		l.Fatal(err)
+	}
+	server := grpc.NewServer(grpc.StatsHandler(&ocgrpc.ServerHandler{}))
+	RegisterFooServer(server, &testServer{})
+	go server.Serve(listener)
+
+	// Initialize client.
+	clientConn, err := grpc.Dial(
+		listener.Addr().String(),
+		grpc.WithInsecure(),
+		grpc.WithStatsHandler(&ocgrpc.ClientHandler{}),
+		grpc.WithBlock())
+
+	if err != nil {
+		l.Fatal(err)
+	}
+	client = NewFooClient(clientConn)
+
+	cleanup = func() {
+		server.GracefulStop()
+		clientConn.Close()
+	}
+
+	return client, cleanup
+}

internal/testpb/test.proto

@@ -4,6 +4,7 @@ package testpb;
 
 message FooRequest {
   bool fail = 1;
+  int64 sleep_nanos = 2;
 }
 
 message FooResponse {