1// Copyright 2019 Google LLC
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     https://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15// Code generated by gapic-generator. DO NOT EDIT.
16
17package spanner
18
19import (
20	"context"
21	"flag"
22	"fmt"
23	"io"
24	"log"
25	"net"
26	"os"
27	"strings"
28	"testing"
29
30	"github.com/golang/protobuf/proto"
31	"github.com/golang/protobuf/ptypes"
32	emptypb "github.com/golang/protobuf/ptypes/empty"
33	"google.golang.org/api/option"
34	spannerpb "google.golang.org/genproto/googleapis/spanner/v1"
35
36	status "google.golang.org/genproto/googleapis/rpc/status"
37	"google.golang.org/grpc"
38	"google.golang.org/grpc/codes"
39	"google.golang.org/grpc/metadata"
40
41	gstatus "google.golang.org/grpc/status"
42)
43
44var _ = io.EOF
45var _ = ptypes.MarshalAny
46var _ status.Status
47
48type mockSpannerServer struct {
49	// Embed for forward compatibility.
50	// Tests will keep working if more methods are added
51	// in the future.
52	spannerpb.SpannerServer
53
54	reqs []proto.Message
55
56	// If set, all calls return this error.
57	err error
58
59	// responses to return if err == nil
60	resps []proto.Message
61}
62
63func (s *mockSpannerServer) CreateSession(ctx context.Context, req *spannerpb.CreateSessionRequest) (*spannerpb.Session, error) {
64	md, _ := metadata.FromIncomingContext(ctx)
65	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
66		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
67	}
68	s.reqs = append(s.reqs, req)
69	if s.err != nil {
70		return nil, s.err
71	}
72	return s.resps[0].(*spannerpb.Session), nil
73}
74
75func (s *mockSpannerServer) BatchCreateSessions(ctx context.Context, req *spannerpb.BatchCreateSessionsRequest) (*spannerpb.BatchCreateSessionsResponse, error) {
76	md, _ := metadata.FromIncomingContext(ctx)
77	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
78		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
79	}
80	s.reqs = append(s.reqs, req)
81	if s.err != nil {
82		return nil, s.err
83	}
84	return s.resps[0].(*spannerpb.BatchCreateSessionsResponse), nil
85}
86
87func (s *mockSpannerServer) GetSession(ctx context.Context, req *spannerpb.GetSessionRequest) (*spannerpb.Session, error) {
88	md, _ := metadata.FromIncomingContext(ctx)
89	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
90		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
91	}
92	s.reqs = append(s.reqs, req)
93	if s.err != nil {
94		return nil, s.err
95	}
96	return s.resps[0].(*spannerpb.Session), nil
97}
98
99func (s *mockSpannerServer) ListSessions(ctx context.Context, req *spannerpb.ListSessionsRequest) (*spannerpb.ListSessionsResponse, error) {
100	md, _ := metadata.FromIncomingContext(ctx)
101	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
102		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
103	}
104	s.reqs = append(s.reqs, req)
105	if s.err != nil {
106		return nil, s.err
107	}
108	return s.resps[0].(*spannerpb.ListSessionsResponse), nil
109}
110
111func (s *mockSpannerServer) DeleteSession(ctx context.Context, req *spannerpb.DeleteSessionRequest) (*emptypb.Empty, error) {
112	md, _ := metadata.FromIncomingContext(ctx)
113	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
114		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
115	}
116	s.reqs = append(s.reqs, req)
117	if s.err != nil {
118		return nil, s.err
119	}
120	return s.resps[0].(*emptypb.Empty), nil
121}
122
123func (s *mockSpannerServer) ExecuteSql(ctx context.Context, req *spannerpb.ExecuteSqlRequest) (*spannerpb.ResultSet, error) {
124	md, _ := metadata.FromIncomingContext(ctx)
125	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
126		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
127	}
128	s.reqs = append(s.reqs, req)
129	if s.err != nil {
130		return nil, s.err
131	}
132	return s.resps[0].(*spannerpb.ResultSet), nil
133}
134
135func (s *mockSpannerServer) ExecuteStreamingSql(req *spannerpb.ExecuteSqlRequest, stream spannerpb.Spanner_ExecuteStreamingSqlServer) error {
136	md, _ := metadata.FromIncomingContext(stream.Context())
137	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
138		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
139	}
140	s.reqs = append(s.reqs, req)
141	if s.err != nil {
142		return s.err
143	}
144	for _, v := range s.resps {
145		if err := stream.Send(v.(*spannerpb.PartialResultSet)); err != nil {
146			return err
147		}
148	}
149	return nil
150}
151
152func (s *mockSpannerServer) ExecuteBatchDml(ctx context.Context, req *spannerpb.ExecuteBatchDmlRequest) (*spannerpb.ExecuteBatchDmlResponse, error) {
153	md, _ := metadata.FromIncomingContext(ctx)
154	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
155		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
156	}
157	s.reqs = append(s.reqs, req)
158	if s.err != nil {
159		return nil, s.err
160	}
161	return s.resps[0].(*spannerpb.ExecuteBatchDmlResponse), nil
162}
163
164func (s *mockSpannerServer) Read(ctx context.Context, req *spannerpb.ReadRequest) (*spannerpb.ResultSet, error) {
165	md, _ := metadata.FromIncomingContext(ctx)
166	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
167		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
168	}
169	s.reqs = append(s.reqs, req)
170	if s.err != nil {
171		return nil, s.err
172	}
173	return s.resps[0].(*spannerpb.ResultSet), nil
174}
175
176func (s *mockSpannerServer) StreamingRead(req *spannerpb.ReadRequest, stream spannerpb.Spanner_StreamingReadServer) error {
177	md, _ := metadata.FromIncomingContext(stream.Context())
178	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
179		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
180	}
181	s.reqs = append(s.reqs, req)
182	if s.err != nil {
183		return s.err
184	}
185	for _, v := range s.resps {
186		if err := stream.Send(v.(*spannerpb.PartialResultSet)); err != nil {
187			return err
188		}
189	}
190	return nil
191}
192
193func (s *mockSpannerServer) BeginTransaction(ctx context.Context, req *spannerpb.BeginTransactionRequest) (*spannerpb.Transaction, error) {
194	md, _ := metadata.FromIncomingContext(ctx)
195	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
196		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
197	}
198	s.reqs = append(s.reqs, req)
199	if s.err != nil {
200		return nil, s.err
201	}
202	return s.resps[0].(*spannerpb.Transaction), nil
203}
204
205func (s *mockSpannerServer) Commit(ctx context.Context, req *spannerpb.CommitRequest) (*spannerpb.CommitResponse, error) {
206	md, _ := metadata.FromIncomingContext(ctx)
207	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
208		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
209	}
210	s.reqs = append(s.reqs, req)
211	if s.err != nil {
212		return nil, s.err
213	}
214	return s.resps[0].(*spannerpb.CommitResponse), nil
215}
216
217func (s *mockSpannerServer) Rollback(ctx context.Context, req *spannerpb.RollbackRequest) (*emptypb.Empty, error) {
218	md, _ := metadata.FromIncomingContext(ctx)
219	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
220		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
221	}
222	s.reqs = append(s.reqs, req)
223	if s.err != nil {
224		return nil, s.err
225	}
226	return s.resps[0].(*emptypb.Empty), nil
227}
228
229func (s *mockSpannerServer) PartitionQuery(ctx context.Context, req *spannerpb.PartitionQueryRequest) (*spannerpb.PartitionResponse, error) {
230	md, _ := metadata.FromIncomingContext(ctx)
231	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
232		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
233	}
234	s.reqs = append(s.reqs, req)
235	if s.err != nil {
236		return nil, s.err
237	}
238	return s.resps[0].(*spannerpb.PartitionResponse), nil
239}
240
241func (s *mockSpannerServer) PartitionRead(ctx context.Context, req *spannerpb.PartitionReadRequest) (*spannerpb.PartitionResponse, error) {
242	md, _ := metadata.FromIncomingContext(ctx)
243	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
244		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
245	}
246	s.reqs = append(s.reqs, req)
247	if s.err != nil {
248		return nil, s.err
249	}
250	return s.resps[0].(*spannerpb.PartitionResponse), nil
251}
252
253// clientOpt is the option tests should use to connect to the test server.
254// It is initialized by TestMain.
255var clientOpt option.ClientOption
256
257var (
258	mockSpanner mockSpannerServer
259)
260
261func TestMain(m *testing.M) {
262	flag.Parse()
263
264	serv := grpc.NewServer()
265	spannerpb.RegisterSpannerServer(serv, &mockSpanner)
266
267	lis, err := net.Listen("tcp", "localhost:0")
268	if err != nil {
269		log.Fatal(err)
270	}
271	go serv.Serve(lis)
272
273	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
274	if err != nil {
275		log.Fatal(err)
276	}
277	clientOpt = option.WithGRPCConn(conn)
278
279	os.Exit(m.Run())
280}
281
282func TestSpannerCreateSession(t *testing.T) {
283	var name string = "name3373707"
284	var expectedResponse = &spannerpb.Session{
285		Name: name,
286	}
287
288	mockSpanner.err = nil
289	mockSpanner.reqs = nil
290
291	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
292
293	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
294	var request = &spannerpb.CreateSessionRequest{
295		Database: formattedDatabase,
296	}
297
298	c, err := NewClient(context.Background(), clientOpt)
299	if err != nil {
300		t.Fatal(err)
301	}
302
303	resp, err := c.CreateSession(context.Background(), request)
304
305	if err != nil {
306		t.Fatal(err)
307	}
308
309	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
310		t.Errorf("wrong request %q, want %q", got, want)
311	}
312
313	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
314		t.Errorf("wrong response %q, want %q)", got, want)
315	}
316}
317
318func TestSpannerCreateSessionError(t *testing.T) {
319	errCode := codes.PermissionDenied
320	mockSpanner.err = gstatus.Error(errCode, "test error")
321
322	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
323	var request = &spannerpb.CreateSessionRequest{
324		Database: formattedDatabase,
325	}
326
327	c, err := NewClient(context.Background(), clientOpt)
328	if err != nil {
329		t.Fatal(err)
330	}
331
332	resp, err := c.CreateSession(context.Background(), request)
333
334	if st, ok := gstatus.FromError(err); !ok {
335		t.Errorf("got error %v, expected grpc error", err)
336	} else if c := st.Code(); c != errCode {
337		t.Errorf("got error code %q, want %q", c, errCode)
338	}
339	_ = resp
340}
341func TestSpannerBatchCreateSessions(t *testing.T) {
342	var expectedResponse *spannerpb.BatchCreateSessionsResponse = &spannerpb.BatchCreateSessionsResponse{}
343
344	mockSpanner.err = nil
345	mockSpanner.reqs = nil
346
347	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
348
349	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
350	var sessionCount int32 = 185691686
351	var request = &spannerpb.BatchCreateSessionsRequest{
352		Database:     formattedDatabase,
353		SessionCount: sessionCount,
354	}
355
356	c, err := NewClient(context.Background(), clientOpt)
357	if err != nil {
358		t.Fatal(err)
359	}
360
361	resp, err := c.BatchCreateSessions(context.Background(), request)
362
363	if err != nil {
364		t.Fatal(err)
365	}
366
367	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
368		t.Errorf("wrong request %q, want %q", got, want)
369	}
370
371	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
372		t.Errorf("wrong response %q, want %q)", got, want)
373	}
374}
375
376func TestSpannerBatchCreateSessionsError(t *testing.T) {
377	errCode := codes.PermissionDenied
378	mockSpanner.err = gstatus.Error(errCode, "test error")
379
380	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
381	var sessionCount int32 = 185691686
382	var request = &spannerpb.BatchCreateSessionsRequest{
383		Database:     formattedDatabase,
384		SessionCount: sessionCount,
385	}
386
387	c, err := NewClient(context.Background(), clientOpt)
388	if err != nil {
389		t.Fatal(err)
390	}
391
392	resp, err := c.BatchCreateSessions(context.Background(), request)
393
394	if st, ok := gstatus.FromError(err); !ok {
395		t.Errorf("got error %v, expected grpc error", err)
396	} else if c := st.Code(); c != errCode {
397		t.Errorf("got error code %q, want %q", c, errCode)
398	}
399	_ = resp
400}
401func TestSpannerGetSession(t *testing.T) {
402	var name2 string = "name2-1052831874"
403	var expectedResponse = &spannerpb.Session{
404		Name: name2,
405	}
406
407	mockSpanner.err = nil
408	mockSpanner.reqs = nil
409
410	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
411
412	var formattedName string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
413	var request = &spannerpb.GetSessionRequest{
414		Name: formattedName,
415	}
416
417	c, err := NewClient(context.Background(), clientOpt)
418	if err != nil {
419		t.Fatal(err)
420	}
421
422	resp, err := c.GetSession(context.Background(), request)
423
424	if err != nil {
425		t.Fatal(err)
426	}
427
428	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
429		t.Errorf("wrong request %q, want %q", got, want)
430	}
431
432	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
433		t.Errorf("wrong response %q, want %q)", got, want)
434	}
435}
436
437func TestSpannerGetSessionError(t *testing.T) {
438	errCode := codes.PermissionDenied
439	mockSpanner.err = gstatus.Error(errCode, "test error")
440
441	var formattedName string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
442	var request = &spannerpb.GetSessionRequest{
443		Name: formattedName,
444	}
445
446	c, err := NewClient(context.Background(), clientOpt)
447	if err != nil {
448		t.Fatal(err)
449	}
450
451	resp, err := c.GetSession(context.Background(), request)
452
453	if st, ok := gstatus.FromError(err); !ok {
454		t.Errorf("got error %v, expected grpc error", err)
455	} else if c := st.Code(); c != errCode {
456		t.Errorf("got error code %q, want %q", c, errCode)
457	}
458	_ = resp
459}
460func TestSpannerListSessions(t *testing.T) {
461	var nextPageToken string = ""
462	var sessionsElement *spannerpb.Session = &spannerpb.Session{}
463	var sessions = []*spannerpb.Session{sessionsElement}
464	var expectedResponse = &spannerpb.ListSessionsResponse{
465		NextPageToken: nextPageToken,
466		Sessions:      sessions,
467	}
468
469	mockSpanner.err = nil
470	mockSpanner.reqs = nil
471
472	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
473
474	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
475	var request = &spannerpb.ListSessionsRequest{
476		Database: formattedDatabase,
477	}
478
479	c, err := NewClient(context.Background(), clientOpt)
480	if err != nil {
481		t.Fatal(err)
482	}
483
484	resp, err := c.ListSessions(context.Background(), request).Next()
485
486	if err != nil {
487		t.Fatal(err)
488	}
489
490	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
491		t.Errorf("wrong request %q, want %q", got, want)
492	}
493
494	want := (interface{})(expectedResponse.Sessions[0])
495	got := (interface{})(resp)
496	var ok bool
497
498	switch want := (want).(type) {
499	case proto.Message:
500		ok = proto.Equal(want, got.(proto.Message))
501	default:
502		ok = want == got
503	}
504	if !ok {
505		t.Errorf("wrong response %q, want %q)", got, want)
506	}
507}
508
509func TestSpannerListSessionsError(t *testing.T) {
510	errCode := codes.PermissionDenied
511	mockSpanner.err = gstatus.Error(errCode, "test error")
512
513	var formattedDatabase string = fmt.Sprintf("projects/%s/instances/%s/databases/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]")
514	var request = &spannerpb.ListSessionsRequest{
515		Database: formattedDatabase,
516	}
517
518	c, err := NewClient(context.Background(), clientOpt)
519	if err != nil {
520		t.Fatal(err)
521	}
522
523	resp, err := c.ListSessions(context.Background(), request).Next()
524
525	if st, ok := gstatus.FromError(err); !ok {
526		t.Errorf("got error %v, expected grpc error", err)
527	} else if c := st.Code(); c != errCode {
528		t.Errorf("got error code %q, want %q", c, errCode)
529	}
530	_ = resp
531}
532func TestSpannerDeleteSession(t *testing.T) {
533	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
534
535	mockSpanner.err = nil
536	mockSpanner.reqs = nil
537
538	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
539
540	var formattedName string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
541	var request = &spannerpb.DeleteSessionRequest{
542		Name: formattedName,
543	}
544
545	c, err := NewClient(context.Background(), clientOpt)
546	if err != nil {
547		t.Fatal(err)
548	}
549
550	err = c.DeleteSession(context.Background(), request)
551
552	if err != nil {
553		t.Fatal(err)
554	}
555
556	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
557		t.Errorf("wrong request %q, want %q", got, want)
558	}
559
560}
561
562func TestSpannerDeleteSessionError(t *testing.T) {
563	errCode := codes.PermissionDenied
564	mockSpanner.err = gstatus.Error(errCode, "test error")
565
566	var formattedName string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
567	var request = &spannerpb.DeleteSessionRequest{
568		Name: formattedName,
569	}
570
571	c, err := NewClient(context.Background(), clientOpt)
572	if err != nil {
573		t.Fatal(err)
574	}
575
576	err = c.DeleteSession(context.Background(), request)
577
578	if st, ok := gstatus.FromError(err); !ok {
579		t.Errorf("got error %v, expected grpc error", err)
580	} else if c := st.Code(); c != errCode {
581		t.Errorf("got error code %q, want %q", c, errCode)
582	}
583}
584func TestSpannerExecuteSql(t *testing.T) {
585	var expectedResponse *spannerpb.ResultSet = &spannerpb.ResultSet{}
586
587	mockSpanner.err = nil
588	mockSpanner.reqs = nil
589
590	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
591
592	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
593	var sql string = "sql114126"
594	var request = &spannerpb.ExecuteSqlRequest{
595		Session: formattedSession,
596		Sql:     sql,
597	}
598
599	c, err := NewClient(context.Background(), clientOpt)
600	if err != nil {
601		t.Fatal(err)
602	}
603
604	resp, err := c.ExecuteSql(context.Background(), request)
605
606	if err != nil {
607		t.Fatal(err)
608	}
609
610	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
611		t.Errorf("wrong request %q, want %q", got, want)
612	}
613
614	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
615		t.Errorf("wrong response %q, want %q)", got, want)
616	}
617}
618
619func TestSpannerExecuteSqlError(t *testing.T) {
620	errCode := codes.PermissionDenied
621	mockSpanner.err = gstatus.Error(errCode, "test error")
622
623	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
624	var sql string = "sql114126"
625	var request = &spannerpb.ExecuteSqlRequest{
626		Session: formattedSession,
627		Sql:     sql,
628	}
629
630	c, err := NewClient(context.Background(), clientOpt)
631	if err != nil {
632		t.Fatal(err)
633	}
634
635	resp, err := c.ExecuteSql(context.Background(), request)
636
637	if st, ok := gstatus.FromError(err); !ok {
638		t.Errorf("got error %v, expected grpc error", err)
639	} else if c := st.Code(); c != errCode {
640		t.Errorf("got error code %q, want %q", c, errCode)
641	}
642	_ = resp
643}
644func TestSpannerExecuteStreamingSql(t *testing.T) {
645	var chunkedValue bool = true
646	var resumeToken []byte = []byte("103")
647	var expectedResponse = &spannerpb.PartialResultSet{
648		ChunkedValue: chunkedValue,
649		ResumeToken:  resumeToken,
650	}
651
652	mockSpanner.err = nil
653	mockSpanner.reqs = nil
654
655	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
656
657	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
658	var sql string = "sql114126"
659	var request = &spannerpb.ExecuteSqlRequest{
660		Session: formattedSession,
661		Sql:     sql,
662	}
663
664	c, err := NewClient(context.Background(), clientOpt)
665	if err != nil {
666		t.Fatal(err)
667	}
668
669	stream, err := c.ExecuteStreamingSql(context.Background(), request)
670	if err != nil {
671		t.Fatal(err)
672	}
673	resp, err := stream.Recv()
674
675	if err != nil {
676		t.Fatal(err)
677	}
678
679	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
680		t.Errorf("wrong request %q, want %q", got, want)
681	}
682
683	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
684		t.Errorf("wrong response %q, want %q)", got, want)
685	}
686}
687
688func TestSpannerExecuteStreamingSqlError(t *testing.T) {
689	errCode := codes.PermissionDenied
690	mockSpanner.err = gstatus.Error(errCode, "test error")
691
692	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
693	var sql string = "sql114126"
694	var request = &spannerpb.ExecuteSqlRequest{
695		Session: formattedSession,
696		Sql:     sql,
697	}
698
699	c, err := NewClient(context.Background(), clientOpt)
700	if err != nil {
701		t.Fatal(err)
702	}
703
704	stream, err := c.ExecuteStreamingSql(context.Background(), request)
705	if err != nil {
706		t.Fatal(err)
707	}
708	resp, err := stream.Recv()
709
710	if st, ok := gstatus.FromError(err); !ok {
711		t.Errorf("got error %v, expected grpc error", err)
712	} else if c := st.Code(); c != errCode {
713		t.Errorf("got error code %q, want %q", c, errCode)
714	}
715	_ = resp
716}
717func TestSpannerExecuteBatchDml(t *testing.T) {
718	var expectedResponse *spannerpb.ExecuteBatchDmlResponse = &spannerpb.ExecuteBatchDmlResponse{}
719
720	mockSpanner.err = nil
721	mockSpanner.reqs = nil
722
723	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
724
725	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
726	var transaction *spannerpb.TransactionSelector = &spannerpb.TransactionSelector{}
727	var statements []*spannerpb.ExecuteBatchDmlRequest_Statement = nil
728	var seqno int64 = 109325920
729	var request = &spannerpb.ExecuteBatchDmlRequest{
730		Session:     formattedSession,
731		Transaction: transaction,
732		Statements:  statements,
733		Seqno:       seqno,
734	}
735
736	c, err := NewClient(context.Background(), clientOpt)
737	if err != nil {
738		t.Fatal(err)
739	}
740
741	resp, err := c.ExecuteBatchDml(context.Background(), request)
742
743	if err != nil {
744		t.Fatal(err)
745	}
746
747	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
748		t.Errorf("wrong request %q, want %q", got, want)
749	}
750
751	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
752		t.Errorf("wrong response %q, want %q)", got, want)
753	}
754}
755
756func TestSpannerExecuteBatchDmlError(t *testing.T) {
757	errCode := codes.PermissionDenied
758	mockSpanner.err = gstatus.Error(errCode, "test error")
759
760	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
761	var transaction *spannerpb.TransactionSelector = &spannerpb.TransactionSelector{}
762	var statements []*spannerpb.ExecuteBatchDmlRequest_Statement = nil
763	var seqno int64 = 109325920
764	var request = &spannerpb.ExecuteBatchDmlRequest{
765		Session:     formattedSession,
766		Transaction: transaction,
767		Statements:  statements,
768		Seqno:       seqno,
769	}
770
771	c, err := NewClient(context.Background(), clientOpt)
772	if err != nil {
773		t.Fatal(err)
774	}
775
776	resp, err := c.ExecuteBatchDml(context.Background(), request)
777
778	if st, ok := gstatus.FromError(err); !ok {
779		t.Errorf("got error %v, expected grpc error", err)
780	} else if c := st.Code(); c != errCode {
781		t.Errorf("got error code %q, want %q", c, errCode)
782	}
783	_ = resp
784}
785func TestSpannerRead(t *testing.T) {
786	var expectedResponse *spannerpb.ResultSet = &spannerpb.ResultSet{}
787
788	mockSpanner.err = nil
789	mockSpanner.reqs = nil
790
791	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
792
793	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
794	var table string = "table110115790"
795	var columns []string = nil
796	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
797	var request = &spannerpb.ReadRequest{
798		Session: formattedSession,
799		Table:   table,
800		Columns: columns,
801		KeySet:  keySet,
802	}
803
804	c, err := NewClient(context.Background(), clientOpt)
805	if err != nil {
806		t.Fatal(err)
807	}
808
809	resp, err := c.Read(context.Background(), request)
810
811	if err != nil {
812		t.Fatal(err)
813	}
814
815	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
816		t.Errorf("wrong request %q, want %q", got, want)
817	}
818
819	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
820		t.Errorf("wrong response %q, want %q)", got, want)
821	}
822}
823
824func TestSpannerReadError(t *testing.T) {
825	errCode := codes.PermissionDenied
826	mockSpanner.err = gstatus.Error(errCode, "test error")
827
828	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
829	var table string = "table110115790"
830	var columns []string = nil
831	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
832	var request = &spannerpb.ReadRequest{
833		Session: formattedSession,
834		Table:   table,
835		Columns: columns,
836		KeySet:  keySet,
837	}
838
839	c, err := NewClient(context.Background(), clientOpt)
840	if err != nil {
841		t.Fatal(err)
842	}
843
844	resp, err := c.Read(context.Background(), request)
845
846	if st, ok := gstatus.FromError(err); !ok {
847		t.Errorf("got error %v, expected grpc error", err)
848	} else if c := st.Code(); c != errCode {
849		t.Errorf("got error code %q, want %q", c, errCode)
850	}
851	_ = resp
852}
853func TestSpannerStreamingRead(t *testing.T) {
854	var chunkedValue bool = true
855	var resumeToken []byte = []byte("103")
856	var expectedResponse = &spannerpb.PartialResultSet{
857		ChunkedValue: chunkedValue,
858		ResumeToken:  resumeToken,
859	}
860
861	mockSpanner.err = nil
862	mockSpanner.reqs = nil
863
864	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
865
866	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
867	var table string = "table110115790"
868	var columns []string = nil
869	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
870	var request = &spannerpb.ReadRequest{
871		Session: formattedSession,
872		Table:   table,
873		Columns: columns,
874		KeySet:  keySet,
875	}
876
877	c, err := NewClient(context.Background(), clientOpt)
878	if err != nil {
879		t.Fatal(err)
880	}
881
882	stream, err := c.StreamingRead(context.Background(), request)
883	if err != nil {
884		t.Fatal(err)
885	}
886	resp, err := stream.Recv()
887
888	if err != nil {
889		t.Fatal(err)
890	}
891
892	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
893		t.Errorf("wrong request %q, want %q", got, want)
894	}
895
896	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
897		t.Errorf("wrong response %q, want %q)", got, want)
898	}
899}
900
901func TestSpannerStreamingReadError(t *testing.T) {
902	errCode := codes.PermissionDenied
903	mockSpanner.err = gstatus.Error(errCode, "test error")
904
905	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
906	var table string = "table110115790"
907	var columns []string = nil
908	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
909	var request = &spannerpb.ReadRequest{
910		Session: formattedSession,
911		Table:   table,
912		Columns: columns,
913		KeySet:  keySet,
914	}
915
916	c, err := NewClient(context.Background(), clientOpt)
917	if err != nil {
918		t.Fatal(err)
919	}
920
921	stream, err := c.StreamingRead(context.Background(), request)
922	if err != nil {
923		t.Fatal(err)
924	}
925	resp, err := stream.Recv()
926
927	if st, ok := gstatus.FromError(err); !ok {
928		t.Errorf("got error %v, expected grpc error", err)
929	} else if c := st.Code(); c != errCode {
930		t.Errorf("got error code %q, want %q", c, errCode)
931	}
932	_ = resp
933}
934func TestSpannerBeginTransaction(t *testing.T) {
935	var id []byte = []byte("27")
936	var expectedResponse = &spannerpb.Transaction{
937		Id: id,
938	}
939
940	mockSpanner.err = nil
941	mockSpanner.reqs = nil
942
943	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
944
945	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
946	var options *spannerpb.TransactionOptions = &spannerpb.TransactionOptions{}
947	var request = &spannerpb.BeginTransactionRequest{
948		Session: formattedSession,
949		Options: options,
950	}
951
952	c, err := NewClient(context.Background(), clientOpt)
953	if err != nil {
954		t.Fatal(err)
955	}
956
957	resp, err := c.BeginTransaction(context.Background(), request)
958
959	if err != nil {
960		t.Fatal(err)
961	}
962
963	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
964		t.Errorf("wrong request %q, want %q", got, want)
965	}
966
967	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
968		t.Errorf("wrong response %q, want %q)", got, want)
969	}
970}
971
972func TestSpannerBeginTransactionError(t *testing.T) {
973	errCode := codes.PermissionDenied
974	mockSpanner.err = gstatus.Error(errCode, "test error")
975
976	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
977	var options *spannerpb.TransactionOptions = &spannerpb.TransactionOptions{}
978	var request = &spannerpb.BeginTransactionRequest{
979		Session: formattedSession,
980		Options: options,
981	}
982
983	c, err := NewClient(context.Background(), clientOpt)
984	if err != nil {
985		t.Fatal(err)
986	}
987
988	resp, err := c.BeginTransaction(context.Background(), request)
989
990	if st, ok := gstatus.FromError(err); !ok {
991		t.Errorf("got error %v, expected grpc error", err)
992	} else if c := st.Code(); c != errCode {
993		t.Errorf("got error code %q, want %q", c, errCode)
994	}
995	_ = resp
996}
997func TestSpannerCommit(t *testing.T) {
998	var expectedResponse *spannerpb.CommitResponse = &spannerpb.CommitResponse{}
999
1000	mockSpanner.err = nil
1001	mockSpanner.reqs = nil
1002
1003	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
1004
1005	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1006	var request = &spannerpb.CommitRequest{
1007		Session: formattedSession,
1008	}
1009
1010	c, err := NewClient(context.Background(), clientOpt)
1011	if err != nil {
1012		t.Fatal(err)
1013	}
1014
1015	resp, err := c.Commit(context.Background(), request)
1016
1017	if err != nil {
1018		t.Fatal(err)
1019	}
1020
1021	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
1022		t.Errorf("wrong request %q, want %q", got, want)
1023	}
1024
1025	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1026		t.Errorf("wrong response %q, want %q)", got, want)
1027	}
1028}
1029
1030func TestSpannerCommitError(t *testing.T) {
1031	errCode := codes.PermissionDenied
1032	mockSpanner.err = gstatus.Error(errCode, "test error")
1033
1034	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1035	var request = &spannerpb.CommitRequest{
1036		Session: formattedSession,
1037	}
1038
1039	c, err := NewClient(context.Background(), clientOpt)
1040	if err != nil {
1041		t.Fatal(err)
1042	}
1043
1044	resp, err := c.Commit(context.Background(), request)
1045
1046	if st, ok := gstatus.FromError(err); !ok {
1047		t.Errorf("got error %v, expected grpc error", err)
1048	} else if c := st.Code(); c != errCode {
1049		t.Errorf("got error code %q, want %q", c, errCode)
1050	}
1051	_ = resp
1052}
1053func TestSpannerRollback(t *testing.T) {
1054	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1055
1056	mockSpanner.err = nil
1057	mockSpanner.reqs = nil
1058
1059	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
1060
1061	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1062	var transactionId []byte = []byte("28")
1063	var request = &spannerpb.RollbackRequest{
1064		Session:       formattedSession,
1065		TransactionId: transactionId,
1066	}
1067
1068	c, err := NewClient(context.Background(), clientOpt)
1069	if err != nil {
1070		t.Fatal(err)
1071	}
1072
1073	err = c.Rollback(context.Background(), request)
1074
1075	if err != nil {
1076		t.Fatal(err)
1077	}
1078
1079	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
1080		t.Errorf("wrong request %q, want %q", got, want)
1081	}
1082
1083}
1084
1085func TestSpannerRollbackError(t *testing.T) {
1086	errCode := codes.PermissionDenied
1087	mockSpanner.err = gstatus.Error(errCode, "test error")
1088
1089	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1090	var transactionId []byte = []byte("28")
1091	var request = &spannerpb.RollbackRequest{
1092		Session:       formattedSession,
1093		TransactionId: transactionId,
1094	}
1095
1096	c, err := NewClient(context.Background(), clientOpt)
1097	if err != nil {
1098		t.Fatal(err)
1099	}
1100
1101	err = c.Rollback(context.Background(), request)
1102
1103	if st, ok := gstatus.FromError(err); !ok {
1104		t.Errorf("got error %v, expected grpc error", err)
1105	} else if c := st.Code(); c != errCode {
1106		t.Errorf("got error code %q, want %q", c, errCode)
1107	}
1108}
1109func TestSpannerPartitionQuery(t *testing.T) {
1110	var expectedResponse *spannerpb.PartitionResponse = &spannerpb.PartitionResponse{}
1111
1112	mockSpanner.err = nil
1113	mockSpanner.reqs = nil
1114
1115	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
1116
1117	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1118	var sql string = "sql114126"
1119	var request = &spannerpb.PartitionQueryRequest{
1120		Session: formattedSession,
1121		Sql:     sql,
1122	}
1123
1124	c, err := NewClient(context.Background(), clientOpt)
1125	if err != nil {
1126		t.Fatal(err)
1127	}
1128
1129	resp, err := c.PartitionQuery(context.Background(), request)
1130
1131	if err != nil {
1132		t.Fatal(err)
1133	}
1134
1135	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
1136		t.Errorf("wrong request %q, want %q", got, want)
1137	}
1138
1139	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1140		t.Errorf("wrong response %q, want %q)", got, want)
1141	}
1142}
1143
1144func TestSpannerPartitionQueryError(t *testing.T) {
1145	errCode := codes.PermissionDenied
1146	mockSpanner.err = gstatus.Error(errCode, "test error")
1147
1148	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1149	var sql string = "sql114126"
1150	var request = &spannerpb.PartitionQueryRequest{
1151		Session: formattedSession,
1152		Sql:     sql,
1153	}
1154
1155	c, err := NewClient(context.Background(), clientOpt)
1156	if err != nil {
1157		t.Fatal(err)
1158	}
1159
1160	resp, err := c.PartitionQuery(context.Background(), request)
1161
1162	if st, ok := gstatus.FromError(err); !ok {
1163		t.Errorf("got error %v, expected grpc error", err)
1164	} else if c := st.Code(); c != errCode {
1165		t.Errorf("got error code %q, want %q", c, errCode)
1166	}
1167	_ = resp
1168}
1169func TestSpannerPartitionRead(t *testing.T) {
1170	var expectedResponse *spannerpb.PartitionResponse = &spannerpb.PartitionResponse{}
1171
1172	mockSpanner.err = nil
1173	mockSpanner.reqs = nil
1174
1175	mockSpanner.resps = append(mockSpanner.resps[:0], expectedResponse)
1176
1177	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1178	var table string = "table110115790"
1179	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
1180	var request = &spannerpb.PartitionReadRequest{
1181		Session: formattedSession,
1182		Table:   table,
1183		KeySet:  keySet,
1184	}
1185
1186	c, err := NewClient(context.Background(), clientOpt)
1187	if err != nil {
1188		t.Fatal(err)
1189	}
1190
1191	resp, err := c.PartitionRead(context.Background(), request)
1192
1193	if err != nil {
1194		t.Fatal(err)
1195	}
1196
1197	if want, got := request, mockSpanner.reqs[0]; !proto.Equal(want, got) {
1198		t.Errorf("wrong request %q, want %q", got, want)
1199	}
1200
1201	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1202		t.Errorf("wrong response %q, want %q)", got, want)
1203	}
1204}
1205
1206func TestSpannerPartitionReadError(t *testing.T) {
1207	errCode := codes.PermissionDenied
1208	mockSpanner.err = gstatus.Error(errCode, "test error")
1209
1210	var formattedSession string = fmt.Sprintf("projects/%s/instances/%s/databases/%s/sessions/%s", "[PROJECT]", "[INSTANCE]", "[DATABASE]", "[SESSION]")
1211	var table string = "table110115790"
1212	var keySet *spannerpb.KeySet = &spannerpb.KeySet{}
1213	var request = &spannerpb.PartitionReadRequest{
1214		Session: formattedSession,
1215		Table:   table,
1216		KeySet:  keySet,
1217	}
1218
1219	c, err := NewClient(context.Background(), clientOpt)
1220	if err != nil {
1221		t.Fatal(err)
1222	}
1223
1224	resp, err := c.PartitionRead(context.Background(), request)
1225
1226	if st, ok := gstatus.FromError(err); !ok {
1227		t.Errorf("got error %v, expected grpc error", err)
1228	} else if c := st.Code(); c != errCode {
1229		t.Errorf("got error code %q, want %q", c, errCode)
1230	}
1231	_ = resp
1232}
1233