vendor: update all dependencies to latest versions

vendor/cloud.google.com/go/spanner/apiv1/doc.go

@@ -0,0 +1,44 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// 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.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+// Package spanner is an experimental, auto-generated package for the
+// Cloud Spanner API.
+//
+// Cloud Spanner is a managed, mission-critical, globally consistent and
+// scalable relational database service.
+//
+// Use the client at cloud.google.com/go/spanner in preference to this.
+package spanner // import "cloud.google.com/go/spanner/apiv1"
+
+import (
+	"golang.org/x/net/context"
+	"google.golang.org/grpc/metadata"
+)
+
+func insertXGoog(ctx context.Context, val []string) context.Context {
+	md, _ := metadata.FromOutgoingContext(ctx)
+	md = md.Copy()
+	md["x-goog-api-client"] = val
+	return metadata.NewOutgoingContext(ctx, md)
+}
+
+// DefaultAuthScopes reports the default set of authentication scopes to use with this package.
+func DefaultAuthScopes() []string {
+	return []string{
+		"https://www.googleapis.com/auth/cloud-platform",
+		"https://www.googleapis.com/auth/spanner.data",
+	}
+}

vendor/cloud.google.com/go/spanner/apiv1/mock_test.go

@@ -0,0 +1,853 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// 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.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package spanner
+
+import (
+	emptypb "github.com/golang/protobuf/ptypes/empty"
+	spannerpb "google.golang.org/genproto/googleapis/spanner/v1"
+)
+
+import (
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	status "google.golang.org/genproto/googleapis/rpc/status"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+	gstatus "google.golang.org/grpc/status"
+)
+
+var _ = io.EOF
+var _ = ptypes.MarshalAny
+var _ status.Status
+
+type mockSpannerServer struct {
+	// Embed for forward compatibility.
+	// Tests will keep working if more methods are added
+	// in the future.
+	spannerpb.SpannerServer
+
+	reqs []proto.Message
+
+	// If set, all calls return this error.
+	err error
+
+	// responses to return if err == nil
+	resps []proto.Message
+}
+
+func (s *mockSpannerServer) CreateSession(ctx context.Context, req *spannerpb.CreateSessionRequest) (*spannerpb.Session, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.Session), nil
+}
+
+func (s *mockSpannerServer) GetSession(ctx context.Context, req *spannerpb.GetSessionRequest) (*spannerpb.Session, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.Session), nil
+}
+
+func (s *mockSpannerServer) DeleteSession(ctx context.Context, req *spannerpb.DeleteSessionRequest) (*emptypb.Empty, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*emptypb.Empty), nil
+}
+
+func (s *mockSpannerServer) ExecuteSql(ctx context.Context, req *spannerpb.ExecuteSqlRequest) (*spannerpb.ResultSet, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.ResultSet), nil
+}
+
+func (s *mockSpannerServer) ExecuteStreamingSql(req *spannerpb.ExecuteSqlRequest, stream spannerpb.Spanner_ExecuteStreamingSqlServer) error {
+	md, _ := metadata.FromIncomingContext(stream.Context())
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return s.err
+	}
+	for _, v := range s.resps {
+		if err := stream.Send(v.(*spannerpb.PartialResultSet)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *mockSpannerServer) Read(ctx context.Context, req *spannerpb.ReadRequest) (*spannerpb.ResultSet, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.ResultSet), nil
+}
+
+func (s *mockSpannerServer) StreamingRead(req *spannerpb.ReadRequest, stream spannerpb.Spanner_StreamingReadServer) error {
+	md, _ := metadata.FromIncomingContext(stream.Context())
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return s.err
+	}
+	for _, v := range s.resps {
+		if err := stream.Send(v.(*spannerpb.PartialResultSet)); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (s *mockSpannerServer) BeginTransaction(ctx context.Context, req *spannerpb.BeginTransactionRequest) (*spannerpb.Transaction, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.Transaction), nil
+}
+
+func (s *mockSpannerServer) Commit(ctx context.Context, req *spannerpb.CommitRequest) (*spannerpb.CommitResponse, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*spannerpb.CommitResponse), nil
+}
+
+func (s *mockSpannerServer) Rollback(ctx context.Context, req *spannerpb.RollbackRequest) (*emptypb.Empty, error) {
+	md, _ := metadata.FromIncomingContext(ctx)
+	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
+		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
+	}
+	s.reqs = append(s.reqs, req)
+	if s.err != nil {
+		return nil, s.err
+	}
+	return s.resps[0].(*emptypb.Empty), nil
+}
+
+// clientOpt is the option tests should use to connect to the test server.
+// It is initialized by TestMain.
+var clientOpt option.ClientOption
+
+var (
+	mockSpanner mockSpannerServer
+)
+
+func TestMain(m *testing.M) {
+	flag.Parse()
+
+	serv := grpc.NewServer()
+	spannerpb.RegisterSpannerServer(serv, &mockSpanner)
+
+	lis, err := net.Listen("tcp", "localhost:0")
+	if err != nil {
+		log.Fatal(err)
+	}
+	go serv.Serve(lis)
+
+	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
+	if err != nil {
+		log.Fatal(err)
+	}
+	clientOpt = option.WithGRPCConn(conn)
+
+	os.Exit(m.Run())
+}
+
+func TestSpannerCreateSession(t *testing.T) {
+	var name string = "name3373707"
+	var expectedResponse = &spannerpb.Session{
+		Name: name,
+	}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedDatabase string = DatabasePath("[PROJECT]", "[INSTANCE]", "[DATABASE]")
+	var request = &spannerpb.CreateSessionRequest{
+		Database: formattedDatabase,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.CreateSession(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerCreateSessionError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedDatabase string = DatabasePath("[PROJECT]", "[INSTANCE]", "[DATABASE]")
+	var request = &spannerpb.CreateSessionRequest{
+		Database: formattedDatabase,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.CreateSession(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerGetSession(t *testing.T) {
+	var name2 string = "name2-1052831874"
+	var expectedResponse = &spannerpb.Session{
+		Name: name2,
+	}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedName string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var request = &spannerpb.GetSessionRequest{
+		Name: formattedName,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.GetSession(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerGetSessionError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedName string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var request = &spannerpb.GetSessionRequest{
+		Name: formattedName,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.GetSession(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerDeleteSession(t *testing.T) {
+	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedName string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var request = &spannerpb.DeleteSessionRequest{
+		Name: formattedName,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = c.DeleteSession(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+}
+
+func TestSpannerDeleteSessionError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedName string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var request = &spannerpb.DeleteSessionRequest{
+		Name: formattedName,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = c.DeleteSession(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+}
+func TestSpannerExecuteSql(t *testing.T) {
+	var expectedResponse *spannerpb.ResultSet = &spannerpb.ResultSet{}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var sql string = "sql114126"
+	var request = &spannerpb.ExecuteSqlRequest{
+		Session: formattedSession,
+		Sql:     sql,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.ExecuteSql(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerExecuteSqlError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var sql string = "sql114126"
+	var request = &spannerpb.ExecuteSqlRequest{
+		Session: formattedSession,
+		Sql:     sql,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.ExecuteSql(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerExecuteStreamingSql(t *testing.T) {
+	var chunkedValue bool = true
+	var resumeToken []byte = []byte("103")
+	var expectedResponse = &spannerpb.PartialResultSet{
+		ChunkedValue: chunkedValue,
+		ResumeToken:  resumeToken,
+	}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var sql string = "sql114126"
+	var request = &spannerpb.ExecuteSqlRequest{
+		Session: formattedSession,
+		Sql:     sql,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stream, err := c.ExecuteStreamingSql(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := stream.Recv()
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerExecuteStreamingSqlError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var sql string = "sql114126"
+	var request = &spannerpb.ExecuteSqlRequest{
+		Session: formattedSession,
+		Sql:     sql,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stream, err := c.ExecuteStreamingSql(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := stream.Recv()
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerRead(t *testing.T) {
+	var expectedResponse *spannerpb.ResultSet = &spannerpb.ResultSet{}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var table string = "table110115790"
+	var columns []string = nil
+	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
+	var request = &spannerpb.ReadRequest{
+		Session: formattedSession,
+		Table:   table,
+		Columns: columns,
+		KeySet:  keySet,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.Read(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerReadError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var table string = "table110115790"
+	var columns []string = nil
+	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
+	var request = &spannerpb.ReadRequest{
+		Session: formattedSession,
+		Table:   table,
+		Columns: columns,
+		KeySet:  keySet,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.Read(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerStreamingRead(t *testing.T) {
+	var chunkedValue bool = true
+	var resumeToken []byte = []byte("103")
+	var expectedResponse = &spannerpb.PartialResultSet{
+		ChunkedValue: chunkedValue,
+		ResumeToken:  resumeToken,
+	}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var table string = "table110115790"
+	var columns []string = nil
+	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
+	var request = &spannerpb.ReadRequest{
+		Session: formattedSession,
+		Table:   table,
+		Columns: columns,
+		KeySet:  keySet,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stream, err := c.StreamingRead(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := stream.Recv()
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerStreamingReadError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var table string = "table110115790"
+	var columns []string = nil
+	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
+	var request = &spannerpb.ReadRequest{
+		Session: formattedSession,
+		Table:   table,
+		Columns: columns,
+		KeySet:  keySet,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	stream, err := c.StreamingRead(context.Background(), request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err := stream.Recv()
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerBeginTransaction(t *testing.T) {
+	var id []byte = []byte("27")
+	var expectedResponse = &spannerpb.Transaction{
+		Id: id,
+	}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var options *spannerpb.TransactionOptions = &spannerpb.TransactionOptions{}
+	var request = &spannerpb.BeginTransactionRequest{
+		Session: formattedSession,
+		Options: options,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.BeginTransaction(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerBeginTransactionError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var options *spannerpb.TransactionOptions = &spannerpb.TransactionOptions{}
+	var request = &spannerpb.BeginTransactionRequest{
+		Session: formattedSession,
+		Options: options,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.BeginTransaction(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerCommit(t *testing.T) {
+	var expectedResponse *spannerpb.CommitResponse = &spannerpb.CommitResponse{}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var mutations []*spannerpb.Mutation = nil
+	var request = &spannerpb.CommitRequest{
+		Session:   formattedSession,
+		Mutations: mutations,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.Commit(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
+		t.Errorf("wrong response %q, want %q)", got, want)
+	}
+}
+
+func TestSpannerCommitError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var mutations []*spannerpb.Mutation = nil
+	var request = &spannerpb.CommitRequest{
+		Session:   formattedSession,
+		Mutations: mutations,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	resp, err := c.Commit(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+	_ = resp
+}
+func TestSpannerRollback(t *testing.T) {
+	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
+
+	mockSpanner.err = nil
+	mockSpanner.reqs = nil
+
+	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var transactionId []byte = []byte("28")
+	var request = &spannerpb.RollbackRequest{
+		Session:       formattedSession,
+		TransactionId: transactionId,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = c.Rollback(context.Background(), request)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
+		t.Errorf("wrong request %q, want %q", got, want)
+	}
+
+}
+
+func TestSpannerRollbackError(t *testing.T) {
+	errCode := codes.PermissionDenied
+	mockSpanner.err = gstatus.Error(errCode, "test error")
+
+	var formattedSession string = SessionPath("[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
+	var transactionId []byte = []byte("28")
+	var request = &spannerpb.RollbackRequest{
+		Session:       formattedSession,
+		TransactionId: transactionId,
+	}
+
+	c, err := NewClient(context.Background(), clientOpt)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = c.Rollback(context.Background(), request)
+
+	if st, ok := gstatus.FromError(err); !ok {
+		t.Errorf("got error %v, expected grpc error", err)
+	} else if c := st.Code(); c != errCode {
+		t.Errorf("got error code %q, want %q", c, errCode)
+	}
+}

vendor/cloud.google.com/go/spanner/apiv1/spanner_client.go

@@ -0,0 +1,392 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// 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.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package spanner
+
+import (
+	"time"
+
+	"cloud.google.com/go/internal/version"
+	gax "github.com/googleapis/gax-go"
+	"golang.org/x/net/context"
+	"google.golang.org/api/option"
+	"google.golang.org/api/transport"
+	spannerpb "google.golang.org/genproto/googleapis/spanner/v1"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+// CallOptions contains the retry settings for each method of Client.
+type CallOptions struct {
+	CreateSession       []gax.CallOption
+	GetSession          []gax.CallOption
+	DeleteSession       []gax.CallOption
+	ExecuteSql          []gax.CallOption
+	ExecuteStreamingSql []gax.CallOption
+	Read                []gax.CallOption
+	StreamingRead       []gax.CallOption
+	BeginTransaction    []gax.CallOption
+	Commit              []gax.CallOption
+	Rollback            []gax.CallOption
+}
+
+func defaultClientOptions() []option.ClientOption {
+	return []option.ClientOption{
+		option.WithEndpoint("spanner.googleapis.com:443"),
+		option.WithScopes(DefaultAuthScopes()...),
+	}
+}
+
+func defaultCallOptions() *CallOptions {
+	retry := map[[2]string][]gax.CallOption{
+		{"default", "idempotent"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.DeadlineExceeded,
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    1000 * time.Millisecond,
+					Max:        32000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+		{"long_running", "long_running"}: {
+			gax.WithRetry(func() gax.Retryer {
+				return gax.OnCodes([]codes.Code{
+					codes.Unavailable,
+				}, gax.Backoff{
+					Initial:    1000 * time.Millisecond,
+					Max:        32000 * time.Millisecond,
+					Multiplier: 1.3,
+				})
+			}),
+		},
+	}
+	return &CallOptions{
+		CreateSession:       retry[[2]string{"default", "idempotent"}],
+		GetSession:          retry[[2]string{"default", "idempotent"}],
+		DeleteSession:       retry[[2]string{"default", "idempotent"}],
+		ExecuteSql:          retry[[2]string{"default", "idempotent"}],
+		ExecuteStreamingSql: retry[[2]string{"default", "non_idempotent"}],
+		Read:                retry[[2]string{"default", "idempotent"}],
+		StreamingRead:       retry[[2]string{"default", "non_idempotent"}],
+		BeginTransaction:    retry[[2]string{"default", "idempotent"}],
+		Commit:              retry[[2]string{"long_running", "long_running"}],
+		Rollback:            retry[[2]string{"default", "idempotent"}],
+	}
+}
+
+// Client is a client for interacting with Cloud Spanner API.
+type Client struct {
+	// The connection to the service.
+	conn *grpc.ClientConn
+
+	// The gRPC API client.
+	client spannerpb.SpannerClient
+
+	// The call options for this service.
+	CallOptions *CallOptions
+
+	// The metadata to be sent with each request.
+	xGoogHeader []string
+}
+
+// NewClient creates a new spanner client.
+//
+// Cloud Spanner API
+//
+// The Cloud Spanner API can be used to manage sessions and execute
+// transactions on data stored in Cloud Spanner databases.
+func NewClient(ctx context.Context, opts ...option.ClientOption) (*Client, error) {
+	conn, err := transport.DialGRPC(ctx, append(defaultClientOptions(), opts...)...)
+	if err != nil {
+		return nil, err
+	}
+	c := &Client{
+		conn:        conn,
+		CallOptions: defaultCallOptions(),
+
+		client: spannerpb.NewSpannerClient(conn),
+	}
+	c.SetGoogleClientInfo()
+	return c, nil
+}
+
+// Connection returns the client's connection to the API service.
+func (c *Client) Connection() *grpc.ClientConn {
+	return c.conn
+}
+
+// Close closes the connection to the API service. The user should invoke this when
+// the client is no longer required.
+func (c *Client) Close() error {
+	return c.conn.Close()
+}
+
+// SetGoogleClientInfo sets the name and version of the application in
+// the `x-goog-api-client` header passed on each request. Intended for
+// use by Google-written clients.
+func (c *Client) SetGoogleClientInfo(keyval ...string) {
+	kv := append([]string{"gl-go", version.Go()}, keyval...)
+	kv = append(kv, "gapic", version.Repo, "gax", gax.Version, "grpc", grpc.Version)
+	c.xGoogHeader = []string{gax.XGoogHeader(kv...)}
+}
+
+// DatabasePath returns the path for the database resource.
+func DatabasePath(project, instance, database string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/instances/" +
+		instance +
+		"/databases/" +
+		database +
+		""
+}
+
+// SessionPath returns the path for the session resource.
+func SessionPath(project, instance, database, session string) string {
+	return "" +
+		"projects/" +
+		project +
+		"/instances/" +
+		instance +
+		"/databases/" +
+		database +
+		"/sessions/" +
+		session +
+		""
+}
+
+// CreateSession creates a new session. A session can be used to perform
+// transactions that read and/or modify data in a Cloud Spanner database.
+// Sessions are meant to be reused for many consecutive
+// transactions.
+//
+// Sessions can only execute one transaction at a time. To execute
+// multiple concurrent read-write/write-only transactions, create
+// multiple sessions. Note that standalone reads and queries use a
+// transaction internally, and count toward the one transaction
+// limit.
+//
+// Cloud Spanner limits the number of sessions that can exist at any given
+// time; thus, it is a good idea to delete idle and/or unneeded sessions.
+// Aside from explicit deletes, Cloud Spanner can delete sessions for which no
+// operations are sent for more than an hour. If a session is deleted,
+// requests to it return NOT_FOUND.
+//
+// Idle sessions can be kept alive by sending a trivial SQL query
+// periodically, e.g., "SELECT 1".
+func (c *Client) CreateSession(ctx context.Context, req *spannerpb.CreateSessionRequest, opts ...gax.CallOption) (*spannerpb.Session, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.CreateSession[0:len(c.CallOptions.CreateSession):len(c.CallOptions.CreateSession)], opts...)
+	var resp *spannerpb.Session
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.CreateSession(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// GetSession gets a session. Returns NOT_FOUND if the session does not exist.
+// This is mainly useful for determining whether a session is still
+// alive.
+func (c *Client) GetSession(ctx context.Context, req *spannerpb.GetSessionRequest, opts ...gax.CallOption) (*spannerpb.Session, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.GetSession[0:len(c.CallOptions.GetSession):len(c.CallOptions.GetSession)], opts...)
+	var resp *spannerpb.Session
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.GetSession(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// DeleteSession ends a session, releasing server resources associated with it.
+func (c *Client) DeleteSession(ctx context.Context, req *spannerpb.DeleteSessionRequest, opts ...gax.CallOption) error {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.DeleteSession[0:len(c.CallOptions.DeleteSession):len(c.CallOptions.DeleteSession)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.client.DeleteSession(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}
+
+// ExecuteSql executes an SQL query, returning all rows in a single reply. This
+// method cannot be used to return a result set larger than 10 MiB;
+// if the query yields more data than that, the query fails with
+// a FAILED_PRECONDITION error.
+//
+// Queries inside read-write transactions might return ABORTED. If
+// this occurs, the application should restart the transaction from
+// the beginning. See [Transaction][google.spanner.v1.Transaction] for more details.
+//
+// Larger result sets can be fetched in streaming fashion by calling
+// [ExecuteStreamingSql][google.spanner.v1.Spanner.ExecuteStreamingSql] instead.
+func (c *Client) ExecuteSql(ctx context.Context, req *spannerpb.ExecuteSqlRequest, opts ...gax.CallOption) (*spannerpb.ResultSet, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.ExecuteSql[0:len(c.CallOptions.ExecuteSql):len(c.CallOptions.ExecuteSql)], opts...)
+	var resp *spannerpb.ResultSet
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.ExecuteSql(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// ExecuteStreamingSql like [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql], except returns the result
+// set as a stream. Unlike [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql], there
+// is no limit on the size of the returned result set. However, no
+// individual row in the result set can exceed 100 MiB, and no
+// column value can exceed 10 MiB.
+func (c *Client) ExecuteStreamingSql(ctx context.Context, req *spannerpb.ExecuteSqlRequest, opts ...gax.CallOption) (spannerpb.Spanner_ExecuteStreamingSqlClient, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.ExecuteStreamingSql[0:len(c.CallOptions.ExecuteStreamingSql):len(c.CallOptions.ExecuteStreamingSql)], opts...)
+	var resp spannerpb.Spanner_ExecuteStreamingSqlClient
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.ExecuteStreamingSql(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// Read reads rows from the database using key lookups and scans, as a
+// simple key/value style alternative to
+// [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql].  This method cannot be used to
+// return a result set larger than 10 MiB; if the read matches more
+// data than that, the read fails with a FAILED_PRECONDITION
+// error.
+//
+// Reads inside read-write transactions might return ABORTED. If
+// this occurs, the application should restart the transaction from
+// the beginning. See [Transaction][google.spanner.v1.Transaction] for more details.
+//
+// Larger result sets can be yielded in streaming fashion by calling
+// [StreamingRead][google.spanner.v1.Spanner.StreamingRead] instead.
+func (c *Client) Read(ctx context.Context, req *spannerpb.ReadRequest, opts ...gax.CallOption) (*spannerpb.ResultSet, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.Read[0:len(c.CallOptions.Read):len(c.CallOptions.Read)], opts...)
+	var resp *spannerpb.ResultSet
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.Read(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// StreamingRead like [Read][google.spanner.v1.Spanner.Read], except returns the result set as a
+// stream. Unlike [Read][google.spanner.v1.Spanner.Read], there is no limit on the
+// size of the returned result set. However, no individual row in
+// the result set can exceed 100 MiB, and no column value can exceed
+// 10 MiB.
+func (c *Client) StreamingRead(ctx context.Context, req *spannerpb.ReadRequest, opts ...gax.CallOption) (spannerpb.Spanner_StreamingReadClient, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.StreamingRead[0:len(c.CallOptions.StreamingRead):len(c.CallOptions.StreamingRead)], opts...)
+	var resp spannerpb.Spanner_StreamingReadClient
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.StreamingRead(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// BeginTransaction begins a new transaction. This step can often be skipped:
+// [Read][google.spanner.v1.Spanner.Read], [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] and
+// [Commit][google.spanner.v1.Spanner.Commit] can begin a new transaction as a
+// side-effect.
+func (c *Client) BeginTransaction(ctx context.Context, req *spannerpb.BeginTransactionRequest, opts ...gax.CallOption) (*spannerpb.Transaction, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.BeginTransaction[0:len(c.CallOptions.BeginTransaction):len(c.CallOptions.BeginTransaction)], opts...)
+	var resp *spannerpb.Transaction
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.BeginTransaction(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// Commit commits a transaction. The request includes the mutations to be
+// applied to rows in the database.
+//
+// Commit might return an ABORTED error. This can occur at any time;
+// commonly, the cause is conflicts with concurrent
+// transactions. However, it can also happen for a variety of other
+// reasons. If Commit returns ABORTED, the caller should re-attempt
+// the transaction from the beginning, re-using the same session.
+func (c *Client) Commit(ctx context.Context, req *spannerpb.CommitRequest, opts ...gax.CallOption) (*spannerpb.CommitResponse, error) {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.Commit[0:len(c.CallOptions.Commit):len(c.CallOptions.Commit)], opts...)
+	var resp *spannerpb.CommitResponse
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		resp, err = c.client.Commit(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// Rollback rolls back a transaction, releasing any locks it holds. It is a good
+// idea to call this for any transaction that includes one or more
+// [Read][google.spanner.v1.Spanner.Read] or [ExecuteSql][google.spanner.v1.Spanner.ExecuteSql] requests and
+// ultimately decides not to commit.
+//
+// Rollback returns OK if it successfully aborts the transaction, the
+// transaction was already aborted, or the transaction is not
+// found. Rollback never returns ABORTED.
+func (c *Client) Rollback(ctx context.Context, req *spannerpb.RollbackRequest, opts ...gax.CallOption) error {
+	ctx = insertXGoog(ctx, c.xGoogHeader)
+	opts = append(c.CallOptions.Rollback[0:len(c.CallOptions.Rollback):len(c.CallOptions.Rollback)], opts...)
+	err := gax.Invoke(ctx, func(ctx context.Context, settings gax.CallSettings) error {
+		var err error
+		_, err = c.client.Rollback(ctx, req, settings.GRPC...)
+		return err
+	}, opts...)
+	return err
+}

vendor/cloud.google.com/go/spanner/apiv1/spanner_client_example_test.go

@@ -0,0 +1,229 @@
+// Copyright 2017, Google Inc. All rights reserved.
+//
+// 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.
+
+// AUTO-GENERATED CODE. DO NOT EDIT.
+
+package spanner_test
+
+import (
+	"io"
+
+	"cloud.google.com/go/spanner/apiv1"
+	"golang.org/x/net/context"
+	spannerpb "google.golang.org/genproto/googleapis/spanner/v1"
+)
+
+func ExampleNewClient() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use client.
+	_ = c
+}
+
+func ExampleClient_CreateSession() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.CreateSessionRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.CreateSession(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_GetSession() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.GetSessionRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.GetSession(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_DeleteSession() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.DeleteSessionRequest{
+	// TODO: Fill request struct fields.
+	}
+	err = c.DeleteSession(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}
+
+func ExampleClient_ExecuteSql() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.ExecuteSqlRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.ExecuteSql(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_ExecuteStreamingSql() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.ExecuteSqlRequest{
+	// TODO: Fill request struct fields.
+	}
+	stream, err := c.ExecuteStreamingSql(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	for {
+		resp, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			// TODO: handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleClient_Read() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.ReadRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.Read(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_StreamingRead() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.ReadRequest{
+	// TODO: Fill request struct fields.
+	}
+	stream, err := c.StreamingRead(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	for {
+		resp, err := stream.Recv()
+		if err == io.EOF {
+			break
+		}
+		if err != nil {
+			// TODO: handle error.
+		}
+		// TODO: Use resp.
+		_ = resp
+	}
+}
+
+func ExampleClient_BeginTransaction() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.BeginTransactionRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.BeginTransaction(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_Commit() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.CommitRequest{
+	// TODO: Fill request struct fields.
+	}
+	resp, err := c.Commit(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+	// TODO: Use resp.
+	_ = resp
+}
+
+func ExampleClient_Rollback() {
+	ctx := context.Background()
+	c, err := spanner.NewClient(ctx)
+	if err != nil {
+		// TODO: Handle error.
+	}
+
+	req := &spannerpb.RollbackRequest{
+	// TODO: Fill request struct fields.
+	}
+	err = c.Rollback(ctx, req)
+	if err != nil {
+		// TODO: Handle error.
+	}
+}