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 pubsub
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	timestamppb "github.com/golang/protobuf/ptypes/timestamp"
34	"google.golang.org/api/option"
35	pubsubpb "google.golang.org/genproto/googleapis/pubsub/v1"
36	field_maskpb "google.golang.org/genproto/protobuf/field_mask"
37
38	status "google.golang.org/genproto/googleapis/rpc/status"
39	"google.golang.org/grpc"
40	"google.golang.org/grpc/codes"
41	"google.golang.org/grpc/metadata"
42
43	gstatus "google.golang.org/grpc/status"
44)
45
46var _ = io.EOF
47var _ = ptypes.MarshalAny
48var _ status.Status
49
50type mockPublisherServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	pubsubpb.PublisherServer
55
56	reqs []proto.Message
57
58	// If set, all calls return this error.
59	err error
60
61	// responses to return if err == nil
62	resps []proto.Message
63}
64
65func (s *mockPublisherServer) CreateTopic(ctx context.Context, req *pubsubpb.Topic) (*pubsubpb.Topic, error) {
66	md, _ := metadata.FromIncomingContext(ctx)
67	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
68		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
69	}
70	s.reqs = append(s.reqs, req)
71	if s.err != nil {
72		return nil, s.err
73	}
74	return s.resps[0].(*pubsubpb.Topic), nil
75}
76
77func (s *mockPublisherServer) UpdateTopic(ctx context.Context, req *pubsubpb.UpdateTopicRequest) (*pubsubpb.Topic, error) {
78	md, _ := metadata.FromIncomingContext(ctx)
79	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
80		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
81	}
82	s.reqs = append(s.reqs, req)
83	if s.err != nil {
84		return nil, s.err
85	}
86	return s.resps[0].(*pubsubpb.Topic), nil
87}
88
89func (s *mockPublisherServer) Publish(ctx context.Context, req *pubsubpb.PublishRequest) (*pubsubpb.PublishResponse, error) {
90	md, _ := metadata.FromIncomingContext(ctx)
91	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
92		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
93	}
94	s.reqs = append(s.reqs, req)
95	if s.err != nil {
96		return nil, s.err
97	}
98	return s.resps[0].(*pubsubpb.PublishResponse), nil
99}
100
101func (s *mockPublisherServer) GetTopic(ctx context.Context, req *pubsubpb.GetTopicRequest) (*pubsubpb.Topic, error) {
102	md, _ := metadata.FromIncomingContext(ctx)
103	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
104		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
105	}
106	s.reqs = append(s.reqs, req)
107	if s.err != nil {
108		return nil, s.err
109	}
110	return s.resps[0].(*pubsubpb.Topic), nil
111}
112
113func (s *mockPublisherServer) ListTopics(ctx context.Context, req *pubsubpb.ListTopicsRequest) (*pubsubpb.ListTopicsResponse, error) {
114	md, _ := metadata.FromIncomingContext(ctx)
115	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
116		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
117	}
118	s.reqs = append(s.reqs, req)
119	if s.err != nil {
120		return nil, s.err
121	}
122	return s.resps[0].(*pubsubpb.ListTopicsResponse), nil
123}
124
125func (s *mockPublisherServer) ListTopicSubscriptions(ctx context.Context, req *pubsubpb.ListTopicSubscriptionsRequest) (*pubsubpb.ListTopicSubscriptionsResponse, error) {
126	md, _ := metadata.FromIncomingContext(ctx)
127	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
128		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
129	}
130	s.reqs = append(s.reqs, req)
131	if s.err != nil {
132		return nil, s.err
133	}
134	return s.resps[0].(*pubsubpb.ListTopicSubscriptionsResponse), nil
135}
136
137func (s *mockPublisherServer) DeleteTopic(ctx context.Context, req *pubsubpb.DeleteTopicRequest) (*emptypb.Empty, error) {
138	md, _ := metadata.FromIncomingContext(ctx)
139	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
140		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
141	}
142	s.reqs = append(s.reqs, req)
143	if s.err != nil {
144		return nil, s.err
145	}
146	return s.resps[0].(*emptypb.Empty), nil
147}
148
149type mockSubscriberServer struct {
150	// Embed for forward compatibility.
151	// Tests will keep working if more methods are added
152	// in the future.
153	pubsubpb.SubscriberServer
154
155	reqs []proto.Message
156
157	// If set, all calls return this error.
158	err error
159
160	// responses to return if err == nil
161	resps []proto.Message
162}
163
164func (s *mockSubscriberServer) CreateSubscription(ctx context.Context, req *pubsubpb.Subscription) (*pubsubpb.Subscription, 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].(*pubsubpb.Subscription), nil
174}
175
176func (s *mockSubscriberServer) GetSubscription(ctx context.Context, req *pubsubpb.GetSubscriptionRequest) (*pubsubpb.Subscription, error) {
177	md, _ := metadata.FromIncomingContext(ctx)
178	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
179		return nil, 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 nil, s.err
184	}
185	return s.resps[0].(*pubsubpb.Subscription), nil
186}
187
188func (s *mockSubscriberServer) UpdateSubscription(ctx context.Context, req *pubsubpb.UpdateSubscriptionRequest) (*pubsubpb.Subscription, error) {
189	md, _ := metadata.FromIncomingContext(ctx)
190	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
191		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
192	}
193	s.reqs = append(s.reqs, req)
194	if s.err != nil {
195		return nil, s.err
196	}
197	return s.resps[0].(*pubsubpb.Subscription), nil
198}
199
200func (s *mockSubscriberServer) ListSubscriptions(ctx context.Context, req *pubsubpb.ListSubscriptionsRequest) (*pubsubpb.ListSubscriptionsResponse, error) {
201	md, _ := metadata.FromIncomingContext(ctx)
202	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
203		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
204	}
205	s.reqs = append(s.reqs, req)
206	if s.err != nil {
207		return nil, s.err
208	}
209	return s.resps[0].(*pubsubpb.ListSubscriptionsResponse), nil
210}
211
212func (s *mockSubscriberServer) DeleteSubscription(ctx context.Context, req *pubsubpb.DeleteSubscriptionRequest) (*emptypb.Empty, error) {
213	md, _ := metadata.FromIncomingContext(ctx)
214	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
215		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
216	}
217	s.reqs = append(s.reqs, req)
218	if s.err != nil {
219		return nil, s.err
220	}
221	return s.resps[0].(*emptypb.Empty), nil
222}
223
224func (s *mockSubscriberServer) ModifyAckDeadline(ctx context.Context, req *pubsubpb.ModifyAckDeadlineRequest) (*emptypb.Empty, error) {
225	md, _ := metadata.FromIncomingContext(ctx)
226	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
227		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
228	}
229	s.reqs = append(s.reqs, req)
230	if s.err != nil {
231		return nil, s.err
232	}
233	return s.resps[0].(*emptypb.Empty), nil
234}
235
236func (s *mockSubscriberServer) Acknowledge(ctx context.Context, req *pubsubpb.AcknowledgeRequest) (*emptypb.Empty, error) {
237	md, _ := metadata.FromIncomingContext(ctx)
238	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
239		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
240	}
241	s.reqs = append(s.reqs, req)
242	if s.err != nil {
243		return nil, s.err
244	}
245	return s.resps[0].(*emptypb.Empty), nil
246}
247
248func (s *mockSubscriberServer) Pull(ctx context.Context, req *pubsubpb.PullRequest) (*pubsubpb.PullResponse, error) {
249	md, _ := metadata.FromIncomingContext(ctx)
250	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
251		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
252	}
253	s.reqs = append(s.reqs, req)
254	if s.err != nil {
255		return nil, s.err
256	}
257	return s.resps[0].(*pubsubpb.PullResponse), nil
258}
259
260func (s *mockSubscriberServer) StreamingPull(stream pubsubpb.Subscriber_StreamingPullServer) error {
261	md, _ := metadata.FromIncomingContext(stream.Context())
262	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
263		return fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
264	}
265	for {
266		if req, err := stream.Recv(); err == io.EOF {
267			break
268		} else if err != nil {
269			return err
270		} else {
271			s.reqs = append(s.reqs, req)
272		}
273	}
274	if s.err != nil {
275		return s.err
276	}
277	for _, v := range s.resps {
278		if err := stream.Send(v.(*pubsubpb.StreamingPullResponse)); err != nil {
279			return err
280		}
281	}
282	return nil
283}
284
285func (s *mockSubscriberServer) ModifyPushConfig(ctx context.Context, req *pubsubpb.ModifyPushConfigRequest) (*emptypb.Empty, error) {
286	md, _ := metadata.FromIncomingContext(ctx)
287	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
288		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
289	}
290	s.reqs = append(s.reqs, req)
291	if s.err != nil {
292		return nil, s.err
293	}
294	return s.resps[0].(*emptypb.Empty), nil
295}
296
297func (s *mockSubscriberServer) ListSnapshots(ctx context.Context, req *pubsubpb.ListSnapshotsRequest) (*pubsubpb.ListSnapshotsResponse, error) {
298	md, _ := metadata.FromIncomingContext(ctx)
299	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
300		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
301	}
302	s.reqs = append(s.reqs, req)
303	if s.err != nil {
304		return nil, s.err
305	}
306	return s.resps[0].(*pubsubpb.ListSnapshotsResponse), nil
307}
308
309func (s *mockSubscriberServer) CreateSnapshot(ctx context.Context, req *pubsubpb.CreateSnapshotRequest) (*pubsubpb.Snapshot, error) {
310	md, _ := metadata.FromIncomingContext(ctx)
311	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
312		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
313	}
314	s.reqs = append(s.reqs, req)
315	if s.err != nil {
316		return nil, s.err
317	}
318	return s.resps[0].(*pubsubpb.Snapshot), nil
319}
320
321func (s *mockSubscriberServer) UpdateSnapshot(ctx context.Context, req *pubsubpb.UpdateSnapshotRequest) (*pubsubpb.Snapshot, error) {
322	md, _ := metadata.FromIncomingContext(ctx)
323	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
324		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
325	}
326	s.reqs = append(s.reqs, req)
327	if s.err != nil {
328		return nil, s.err
329	}
330	return s.resps[0].(*pubsubpb.Snapshot), nil
331}
332
333func (s *mockSubscriberServer) DeleteSnapshot(ctx context.Context, req *pubsubpb.DeleteSnapshotRequest) (*emptypb.Empty, error) {
334	md, _ := metadata.FromIncomingContext(ctx)
335	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
336		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
337	}
338	s.reqs = append(s.reqs, req)
339	if s.err != nil {
340		return nil, s.err
341	}
342	return s.resps[0].(*emptypb.Empty), nil
343}
344
345func (s *mockSubscriberServer) Seek(ctx context.Context, req *pubsubpb.SeekRequest) (*pubsubpb.SeekResponse, error) {
346	md, _ := metadata.FromIncomingContext(ctx)
347	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
348		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
349	}
350	s.reqs = append(s.reqs, req)
351	if s.err != nil {
352		return nil, s.err
353	}
354	return s.resps[0].(*pubsubpb.SeekResponse), nil
355}
356
357// clientOpt is the option tests should use to connect to the test server.
358// It is initialized by TestMain.
359var clientOpt option.ClientOption
360
361var (
362	mockPublisher  mockPublisherServer
363	mockSubscriber mockSubscriberServer
364)
365
366func TestMain(m *testing.M) {
367	flag.Parse()
368
369	serv := grpc.NewServer()
370	pubsubpb.RegisterPublisherServer(serv, &mockPublisher)
371	pubsubpb.RegisterSubscriberServer(serv, &mockSubscriber)
372
373	lis, err := net.Listen("tcp", "localhost:0")
374	if err != nil {
375		log.Fatal(err)
376	}
377	go serv.Serve(lis)
378
379	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
380	if err != nil {
381		log.Fatal(err)
382	}
383	clientOpt = option.WithGRPCConn(conn)
384
385	os.Exit(m.Run())
386}
387
388func TestPublisherCreateTopic(t *testing.T) {
389	var name2 string = "name2-1052831874"
390	var kmsKeyName string = "kmsKeyName2094986649"
391	var expectedResponse = &pubsubpb.Topic{
392		Name:       name2,
393		KmsKeyName: kmsKeyName,
394	}
395
396	mockPublisher.err = nil
397	mockPublisher.reqs = nil
398
399	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
400
401	var formattedName string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
402	var request = &pubsubpb.Topic{
403		Name: formattedName,
404	}
405
406	c, err := NewPublisherClient(context.Background(), clientOpt)
407	if err != nil {
408		t.Fatal(err)
409	}
410
411	resp, err := c.CreateTopic(context.Background(), request)
412
413	if err != nil {
414		t.Fatal(err)
415	}
416
417	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
418		t.Errorf("wrong request %q, want %q", got, want)
419	}
420
421	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
422		t.Errorf("wrong response %q, want %q)", got, want)
423	}
424}
425
426func TestPublisherCreateTopicError(t *testing.T) {
427	errCode := codes.PermissionDenied
428	mockPublisher.err = gstatus.Error(errCode, "test error")
429
430	var formattedName string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
431	var request = &pubsubpb.Topic{
432		Name: formattedName,
433	}
434
435	c, err := NewPublisherClient(context.Background(), clientOpt)
436	if err != nil {
437		t.Fatal(err)
438	}
439
440	resp, err := c.CreateTopic(context.Background(), request)
441
442	if st, ok := gstatus.FromError(err); !ok {
443		t.Errorf("got error %v, expected grpc error", err)
444	} else if c := st.Code(); c != errCode {
445		t.Errorf("got error code %q, want %q", c, errCode)
446	}
447	_ = resp
448}
449func TestPublisherUpdateTopic(t *testing.T) {
450	var name string = "name3373707"
451	var kmsKeyName string = "kmsKeyName2094986649"
452	var expectedResponse = &pubsubpb.Topic{
453		Name:       name,
454		KmsKeyName: kmsKeyName,
455	}
456
457	mockPublisher.err = nil
458	mockPublisher.reqs = nil
459
460	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
461
462	var topic *pubsubpb.Topic = &pubsubpb.Topic{}
463	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
464	var request = &pubsubpb.UpdateTopicRequest{
465		Topic:      topic,
466		UpdateMask: updateMask,
467	}
468
469	c, err := NewPublisherClient(context.Background(), clientOpt)
470	if err != nil {
471		t.Fatal(err)
472	}
473
474	resp, err := c.UpdateTopic(context.Background(), request)
475
476	if err != nil {
477		t.Fatal(err)
478	}
479
480	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
481		t.Errorf("wrong request %q, want %q", got, want)
482	}
483
484	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
485		t.Errorf("wrong response %q, want %q)", got, want)
486	}
487}
488
489func TestPublisherUpdateTopicError(t *testing.T) {
490	errCode := codes.PermissionDenied
491	mockPublisher.err = gstatus.Error(errCode, "test error")
492
493	var topic *pubsubpb.Topic = &pubsubpb.Topic{}
494	var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{}
495	var request = &pubsubpb.UpdateTopicRequest{
496		Topic:      topic,
497		UpdateMask: updateMask,
498	}
499
500	c, err := NewPublisherClient(context.Background(), clientOpt)
501	if err != nil {
502		t.Fatal(err)
503	}
504
505	resp, err := c.UpdateTopic(context.Background(), request)
506
507	if st, ok := gstatus.FromError(err); !ok {
508		t.Errorf("got error %v, expected grpc error", err)
509	} else if c := st.Code(); c != errCode {
510		t.Errorf("got error code %q, want %q", c, errCode)
511	}
512	_ = resp
513}
514func TestPublisherPublish(t *testing.T) {
515	var messageIdsElement string = "messageIdsElement-744837059"
516	var messageIds = []string{messageIdsElement}
517	var expectedResponse = &pubsubpb.PublishResponse{
518		MessageIds: messageIds,
519	}
520
521	mockPublisher.err = nil
522	mockPublisher.reqs = nil
523
524	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
525
526	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
527	var data []byte = []byte("-86")
528	var messagesElement = &pubsubpb.PubsubMessage{
529		Data: data,
530	}
531	var messages = []*pubsubpb.PubsubMessage{messagesElement}
532	var request = &pubsubpb.PublishRequest{
533		Topic:    formattedTopic,
534		Messages: messages,
535	}
536
537	c, err := NewPublisherClient(context.Background(), clientOpt)
538	if err != nil {
539		t.Fatal(err)
540	}
541
542	resp, err := c.Publish(context.Background(), request)
543
544	if err != nil {
545		t.Fatal(err)
546	}
547
548	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
549		t.Errorf("wrong request %q, want %q", got, want)
550	}
551
552	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
553		t.Errorf("wrong response %q, want %q)", got, want)
554	}
555}
556
557func TestPublisherPublishError(t *testing.T) {
558	errCode := codes.PermissionDenied
559	mockPublisher.err = gstatus.Error(errCode, "test error")
560
561	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
562	var data []byte = []byte("-86")
563	var messagesElement = &pubsubpb.PubsubMessage{
564		Data: data,
565	}
566	var messages = []*pubsubpb.PubsubMessage{messagesElement}
567	var request = &pubsubpb.PublishRequest{
568		Topic:    formattedTopic,
569		Messages: messages,
570	}
571
572	c, err := NewPublisherClient(context.Background(), clientOpt)
573	if err != nil {
574		t.Fatal(err)
575	}
576
577	resp, err := c.Publish(context.Background(), request)
578
579	if st, ok := gstatus.FromError(err); !ok {
580		t.Errorf("got error %v, expected grpc error", err)
581	} else if c := st.Code(); c != errCode {
582		t.Errorf("got error code %q, want %q", c, errCode)
583	}
584	_ = resp
585}
586func TestPublisherGetTopic(t *testing.T) {
587	var name string = "name3373707"
588	var kmsKeyName string = "kmsKeyName2094986649"
589	var expectedResponse = &pubsubpb.Topic{
590		Name:       name,
591		KmsKeyName: kmsKeyName,
592	}
593
594	mockPublisher.err = nil
595	mockPublisher.reqs = nil
596
597	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
598
599	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
600	var request = &pubsubpb.GetTopicRequest{
601		Topic: formattedTopic,
602	}
603
604	c, err := NewPublisherClient(context.Background(), clientOpt)
605	if err != nil {
606		t.Fatal(err)
607	}
608
609	resp, err := c.GetTopic(context.Background(), request)
610
611	if err != nil {
612		t.Fatal(err)
613	}
614
615	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
616		t.Errorf("wrong request %q, want %q", got, want)
617	}
618
619	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
620		t.Errorf("wrong response %q, want %q)", got, want)
621	}
622}
623
624func TestPublisherGetTopicError(t *testing.T) {
625	errCode := codes.PermissionDenied
626	mockPublisher.err = gstatus.Error(errCode, "test error")
627
628	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
629	var request = &pubsubpb.GetTopicRequest{
630		Topic: formattedTopic,
631	}
632
633	c, err := NewPublisherClient(context.Background(), clientOpt)
634	if err != nil {
635		t.Fatal(err)
636	}
637
638	resp, err := c.GetTopic(context.Background(), request)
639
640	if st, ok := gstatus.FromError(err); !ok {
641		t.Errorf("got error %v, expected grpc error", err)
642	} else if c := st.Code(); c != errCode {
643		t.Errorf("got error code %q, want %q", c, errCode)
644	}
645	_ = resp
646}
647func TestPublisherListTopics(t *testing.T) {
648	var nextPageToken string = ""
649	var topicsElement *pubsubpb.Topic = &pubsubpb.Topic{}
650	var topics = []*pubsubpb.Topic{topicsElement}
651	var expectedResponse = &pubsubpb.ListTopicsResponse{
652		NextPageToken: nextPageToken,
653		Topics:        topics,
654	}
655
656	mockPublisher.err = nil
657	mockPublisher.reqs = nil
658
659	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
660
661	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
662	var request = &pubsubpb.ListTopicsRequest{
663		Project: formattedProject,
664	}
665
666	c, err := NewPublisherClient(context.Background(), clientOpt)
667	if err != nil {
668		t.Fatal(err)
669	}
670
671	resp, err := c.ListTopics(context.Background(), request).Next()
672
673	if err != nil {
674		t.Fatal(err)
675	}
676
677	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
678		t.Errorf("wrong request %q, want %q", got, want)
679	}
680
681	want := (interface{})(expectedResponse.Topics[0])
682	got := (interface{})(resp)
683	var ok bool
684
685	switch want := (want).(type) {
686	case proto.Message:
687		ok = proto.Equal(want, got.(proto.Message))
688	default:
689		ok = want == got
690	}
691	if !ok {
692		t.Errorf("wrong response %q, want %q)", got, want)
693	}
694}
695
696func TestPublisherListTopicsError(t *testing.T) {
697	errCode := codes.PermissionDenied
698	mockPublisher.err = gstatus.Error(errCode, "test error")
699
700	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
701	var request = &pubsubpb.ListTopicsRequest{
702		Project: formattedProject,
703	}
704
705	c, err := NewPublisherClient(context.Background(), clientOpt)
706	if err != nil {
707		t.Fatal(err)
708	}
709
710	resp, err := c.ListTopics(context.Background(), request).Next()
711
712	if st, ok := gstatus.FromError(err); !ok {
713		t.Errorf("got error %v, expected grpc error", err)
714	} else if c := st.Code(); c != errCode {
715		t.Errorf("got error code %q, want %q", c, errCode)
716	}
717	_ = resp
718}
719func TestPublisherListTopicSubscriptions(t *testing.T) {
720	var nextPageToken string = ""
721	var subscriptionsElement string = "subscriptionsElement1698708147"
722	var subscriptions = []string{subscriptionsElement}
723	var expectedResponse = &pubsubpb.ListTopicSubscriptionsResponse{
724		NextPageToken: nextPageToken,
725		Subscriptions: subscriptions,
726	}
727
728	mockPublisher.err = nil
729	mockPublisher.reqs = nil
730
731	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
732
733	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
734	var request = &pubsubpb.ListTopicSubscriptionsRequest{
735		Topic: formattedTopic,
736	}
737
738	c, err := NewPublisherClient(context.Background(), clientOpt)
739	if err != nil {
740		t.Fatal(err)
741	}
742
743	resp, err := c.ListTopicSubscriptions(context.Background(), request).Next()
744
745	if err != nil {
746		t.Fatal(err)
747	}
748
749	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
750		t.Errorf("wrong request %q, want %q", got, want)
751	}
752
753	want := (interface{})(expectedResponse.Subscriptions[0])
754	got := (interface{})(resp)
755	var ok bool
756
757	switch want := (want).(type) {
758	case proto.Message:
759		ok = proto.Equal(want, got.(proto.Message))
760	default:
761		ok = want == got
762	}
763	if !ok {
764		t.Errorf("wrong response %q, want %q)", got, want)
765	}
766}
767
768func TestPublisherListTopicSubscriptionsError(t *testing.T) {
769	errCode := codes.PermissionDenied
770	mockPublisher.err = gstatus.Error(errCode, "test error")
771
772	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
773	var request = &pubsubpb.ListTopicSubscriptionsRequest{
774		Topic: formattedTopic,
775	}
776
777	c, err := NewPublisherClient(context.Background(), clientOpt)
778	if err != nil {
779		t.Fatal(err)
780	}
781
782	resp, err := c.ListTopicSubscriptions(context.Background(), request).Next()
783
784	if st, ok := gstatus.FromError(err); !ok {
785		t.Errorf("got error %v, expected grpc error", err)
786	} else if c := st.Code(); c != errCode {
787		t.Errorf("got error code %q, want %q", c, errCode)
788	}
789	_ = resp
790}
791func TestPublisherDeleteTopic(t *testing.T) {
792	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
793
794	mockPublisher.err = nil
795	mockPublisher.reqs = nil
796
797	mockPublisher.resps = append(mockPublisher.resps[:0], expectedResponse)
798
799	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
800	var request = &pubsubpb.DeleteTopicRequest{
801		Topic: formattedTopic,
802	}
803
804	c, err := NewPublisherClient(context.Background(), clientOpt)
805	if err != nil {
806		t.Fatal(err)
807	}
808
809	err = c.DeleteTopic(context.Background(), request)
810
811	if err != nil {
812		t.Fatal(err)
813	}
814
815	if want, got := request, mockPublisher.reqs[0]; !proto.Equal(want, got) {
816		t.Errorf("wrong request %q, want %q", got, want)
817	}
818
819}
820
821func TestPublisherDeleteTopicError(t *testing.T) {
822	errCode := codes.PermissionDenied
823	mockPublisher.err = gstatus.Error(errCode, "test error")
824
825	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
826	var request = &pubsubpb.DeleteTopicRequest{
827		Topic: formattedTopic,
828	}
829
830	c, err := NewPublisherClient(context.Background(), clientOpt)
831	if err != nil {
832		t.Fatal(err)
833	}
834
835	err = c.DeleteTopic(context.Background(), request)
836
837	if st, ok := gstatus.FromError(err); !ok {
838		t.Errorf("got error %v, expected grpc error", err)
839	} else if c := st.Code(); c != errCode {
840		t.Errorf("got error code %q, want %q", c, errCode)
841	}
842}
843func TestSubscriberCreateSubscription(t *testing.T) {
844	var name2 string = "name2-1052831874"
845	var topic2 string = "topic2-1139259102"
846	var ackDeadlineSeconds int32 = 2135351438
847	var retainAckedMessages bool = false
848	var enableMessageOrdering bool = true
849	var expectedResponse = &pubsubpb.Subscription{
850		Name:                  name2,
851		Topic:                 topic2,
852		AckDeadlineSeconds:    ackDeadlineSeconds,
853		RetainAckedMessages:   retainAckedMessages,
854		EnableMessageOrdering: enableMessageOrdering,
855	}
856
857	mockSubscriber.err = nil
858	mockSubscriber.reqs = nil
859
860	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
861
862	var formattedName string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
863	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
864	var request = &pubsubpb.Subscription{
865		Name:  formattedName,
866		Topic: formattedTopic,
867	}
868
869	c, err := NewSubscriberClient(context.Background(), clientOpt)
870	if err != nil {
871		t.Fatal(err)
872	}
873
874	resp, err := c.CreateSubscription(context.Background(), request)
875
876	if err != nil {
877		t.Fatal(err)
878	}
879
880	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
881		t.Errorf("wrong request %q, want %q", got, want)
882	}
883
884	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
885		t.Errorf("wrong response %q, want %q)", got, want)
886	}
887}
888
889func TestSubscriberCreateSubscriptionError(t *testing.T) {
890	errCode := codes.PermissionDenied
891	mockSubscriber.err = gstatus.Error(errCode, "test error")
892
893	var formattedName string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
894	var formattedTopic string = fmt.Sprintf("projects/%s/topics/%s", "[PROJECT]", "[TOPIC]")
895	var request = &pubsubpb.Subscription{
896		Name:  formattedName,
897		Topic: formattedTopic,
898	}
899
900	c, err := NewSubscriberClient(context.Background(), clientOpt)
901	if err != nil {
902		t.Fatal(err)
903	}
904
905	resp, err := c.CreateSubscription(context.Background(), request)
906
907	if st, ok := gstatus.FromError(err); !ok {
908		t.Errorf("got error %v, expected grpc error", err)
909	} else if c := st.Code(); c != errCode {
910		t.Errorf("got error code %q, want %q", c, errCode)
911	}
912	_ = resp
913}
914func TestSubscriberGetSubscription(t *testing.T) {
915	var name string = "name3373707"
916	var topic string = "topic110546223"
917	var ackDeadlineSeconds int32 = 2135351438
918	var retainAckedMessages bool = false
919	var enableMessageOrdering bool = true
920	var expectedResponse = &pubsubpb.Subscription{
921		Name:                  name,
922		Topic:                 topic,
923		AckDeadlineSeconds:    ackDeadlineSeconds,
924		RetainAckedMessages:   retainAckedMessages,
925		EnableMessageOrdering: enableMessageOrdering,
926	}
927
928	mockSubscriber.err = nil
929	mockSubscriber.reqs = nil
930
931	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
932
933	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
934	var request = &pubsubpb.GetSubscriptionRequest{
935		Subscription: formattedSubscription,
936	}
937
938	c, err := NewSubscriberClient(context.Background(), clientOpt)
939	if err != nil {
940		t.Fatal(err)
941	}
942
943	resp, err := c.GetSubscription(context.Background(), request)
944
945	if err != nil {
946		t.Fatal(err)
947	}
948
949	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
950		t.Errorf("wrong request %q, want %q", got, want)
951	}
952
953	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
954		t.Errorf("wrong response %q, want %q)", got, want)
955	}
956}
957
958func TestSubscriberGetSubscriptionError(t *testing.T) {
959	errCode := codes.PermissionDenied
960	mockSubscriber.err = gstatus.Error(errCode, "test error")
961
962	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
963	var request = &pubsubpb.GetSubscriptionRequest{
964		Subscription: formattedSubscription,
965	}
966
967	c, err := NewSubscriberClient(context.Background(), clientOpt)
968	if err != nil {
969		t.Fatal(err)
970	}
971
972	resp, err := c.GetSubscription(context.Background(), request)
973
974	if st, ok := gstatus.FromError(err); !ok {
975		t.Errorf("got error %v, expected grpc error", err)
976	} else if c := st.Code(); c != errCode {
977		t.Errorf("got error code %q, want %q", c, errCode)
978	}
979	_ = resp
980}
981func TestSubscriberUpdateSubscription(t *testing.T) {
982	var name string = "name3373707"
983	var topic string = "topic110546223"
984	var ackDeadlineSeconds2 int32 = 921632575
985	var retainAckedMessages bool = false
986	var enableMessageOrdering bool = true
987	var expectedResponse = &pubsubpb.Subscription{
988		Name:                  name,
989		Topic:                 topic,
990		AckDeadlineSeconds:    ackDeadlineSeconds2,
991		RetainAckedMessages:   retainAckedMessages,
992		EnableMessageOrdering: enableMessageOrdering,
993	}
994
995	mockSubscriber.err = nil
996	mockSubscriber.reqs = nil
997
998	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
999
1000	var ackDeadlineSeconds int32 = 42
1001	var subscription = &pubsubpb.Subscription{
1002		AckDeadlineSeconds: ackDeadlineSeconds,
1003	}
1004	var pathsElement string = "ack_deadline_seconds"
1005	var paths = []string{pathsElement}
1006	var updateMask = &field_maskpb.FieldMask{
1007		Paths: paths,
1008	}
1009	var request = &pubsubpb.UpdateSubscriptionRequest{
1010		Subscription: subscription,
1011		UpdateMask:   updateMask,
1012	}
1013
1014	c, err := NewSubscriberClient(context.Background(), clientOpt)
1015	if err != nil {
1016		t.Fatal(err)
1017	}
1018
1019	resp, err := c.UpdateSubscription(context.Background(), request)
1020
1021	if err != nil {
1022		t.Fatal(err)
1023	}
1024
1025	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1026		t.Errorf("wrong request %q, want %q", got, want)
1027	}
1028
1029	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1030		t.Errorf("wrong response %q, want %q)", got, want)
1031	}
1032}
1033
1034func TestSubscriberUpdateSubscriptionError(t *testing.T) {
1035	errCode := codes.PermissionDenied
1036	mockSubscriber.err = gstatus.Error(errCode, "test error")
1037
1038	var ackDeadlineSeconds int32 = 42
1039	var subscription = &pubsubpb.Subscription{
1040		AckDeadlineSeconds: ackDeadlineSeconds,
1041	}
1042	var pathsElement string = "ack_deadline_seconds"
1043	var paths = []string{pathsElement}
1044	var updateMask = &field_maskpb.FieldMask{
1045		Paths: paths,
1046	}
1047	var request = &pubsubpb.UpdateSubscriptionRequest{
1048		Subscription: subscription,
1049		UpdateMask:   updateMask,
1050	}
1051
1052	c, err := NewSubscriberClient(context.Background(), clientOpt)
1053	if err != nil {
1054		t.Fatal(err)
1055	}
1056
1057	resp, err := c.UpdateSubscription(context.Background(), request)
1058
1059	if st, ok := gstatus.FromError(err); !ok {
1060		t.Errorf("got error %v, expected grpc error", err)
1061	} else if c := st.Code(); c != errCode {
1062		t.Errorf("got error code %q, want %q", c, errCode)
1063	}
1064	_ = resp
1065}
1066func TestSubscriberListSubscriptions(t *testing.T) {
1067	var nextPageToken string = ""
1068	var subscriptionsElement *pubsubpb.Subscription = &pubsubpb.Subscription{}
1069	var subscriptions = []*pubsubpb.Subscription{subscriptionsElement}
1070	var expectedResponse = &pubsubpb.ListSubscriptionsResponse{
1071		NextPageToken: nextPageToken,
1072		Subscriptions: subscriptions,
1073	}
1074
1075	mockSubscriber.err = nil
1076	mockSubscriber.reqs = nil
1077
1078	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1079
1080	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
1081	var request = &pubsubpb.ListSubscriptionsRequest{
1082		Project: formattedProject,
1083	}
1084
1085	c, err := NewSubscriberClient(context.Background(), clientOpt)
1086	if err != nil {
1087		t.Fatal(err)
1088	}
1089
1090	resp, err := c.ListSubscriptions(context.Background(), request).Next()
1091
1092	if err != nil {
1093		t.Fatal(err)
1094	}
1095
1096	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1097		t.Errorf("wrong request %q, want %q", got, want)
1098	}
1099
1100	want := (interface{})(expectedResponse.Subscriptions[0])
1101	got := (interface{})(resp)
1102	var ok bool
1103
1104	switch want := (want).(type) {
1105	case proto.Message:
1106		ok = proto.Equal(want, got.(proto.Message))
1107	default:
1108		ok = want == got
1109	}
1110	if !ok {
1111		t.Errorf("wrong response %q, want %q)", got, want)
1112	}
1113}
1114
1115func TestSubscriberListSubscriptionsError(t *testing.T) {
1116	errCode := codes.PermissionDenied
1117	mockSubscriber.err = gstatus.Error(errCode, "test error")
1118
1119	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
1120	var request = &pubsubpb.ListSubscriptionsRequest{
1121		Project: formattedProject,
1122	}
1123
1124	c, err := NewSubscriberClient(context.Background(), clientOpt)
1125	if err != nil {
1126		t.Fatal(err)
1127	}
1128
1129	resp, err := c.ListSubscriptions(context.Background(), request).Next()
1130
1131	if st, ok := gstatus.FromError(err); !ok {
1132		t.Errorf("got error %v, expected grpc error", err)
1133	} else if c := st.Code(); c != errCode {
1134		t.Errorf("got error code %q, want %q", c, errCode)
1135	}
1136	_ = resp
1137}
1138func TestSubscriberDeleteSubscription(t *testing.T) {
1139	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1140
1141	mockSubscriber.err = nil
1142	mockSubscriber.reqs = nil
1143
1144	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1145
1146	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1147	var request = &pubsubpb.DeleteSubscriptionRequest{
1148		Subscription: formattedSubscription,
1149	}
1150
1151	c, err := NewSubscriberClient(context.Background(), clientOpt)
1152	if err != nil {
1153		t.Fatal(err)
1154	}
1155
1156	err = c.DeleteSubscription(context.Background(), request)
1157
1158	if err != nil {
1159		t.Fatal(err)
1160	}
1161
1162	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1163		t.Errorf("wrong request %q, want %q", got, want)
1164	}
1165
1166}
1167
1168func TestSubscriberDeleteSubscriptionError(t *testing.T) {
1169	errCode := codes.PermissionDenied
1170	mockSubscriber.err = gstatus.Error(errCode, "test error")
1171
1172	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1173	var request = &pubsubpb.DeleteSubscriptionRequest{
1174		Subscription: formattedSubscription,
1175	}
1176
1177	c, err := NewSubscriberClient(context.Background(), clientOpt)
1178	if err != nil {
1179		t.Fatal(err)
1180	}
1181
1182	err = c.DeleteSubscription(context.Background(), request)
1183
1184	if st, ok := gstatus.FromError(err); !ok {
1185		t.Errorf("got error %v, expected grpc error", err)
1186	} else if c := st.Code(); c != errCode {
1187		t.Errorf("got error code %q, want %q", c, errCode)
1188	}
1189}
1190func TestSubscriberModifyAckDeadline(t *testing.T) {
1191	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1192
1193	mockSubscriber.err = nil
1194	mockSubscriber.reqs = nil
1195
1196	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1197
1198	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1199	var ackIds []string = nil
1200	var ackDeadlineSeconds int32 = 2135351438
1201	var request = &pubsubpb.ModifyAckDeadlineRequest{
1202		Subscription:       formattedSubscription,
1203		AckIds:             ackIds,
1204		AckDeadlineSeconds: ackDeadlineSeconds,
1205	}
1206
1207	c, err := NewSubscriberClient(context.Background(), clientOpt)
1208	if err != nil {
1209		t.Fatal(err)
1210	}
1211
1212	err = c.ModifyAckDeadline(context.Background(), request)
1213
1214	if err != nil {
1215		t.Fatal(err)
1216	}
1217
1218	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1219		t.Errorf("wrong request %q, want %q", got, want)
1220	}
1221
1222}
1223
1224func TestSubscriberModifyAckDeadlineError(t *testing.T) {
1225	errCode := codes.PermissionDenied
1226	mockSubscriber.err = gstatus.Error(errCode, "test error")
1227
1228	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1229	var ackIds []string = nil
1230	var ackDeadlineSeconds int32 = 2135351438
1231	var request = &pubsubpb.ModifyAckDeadlineRequest{
1232		Subscription:       formattedSubscription,
1233		AckIds:             ackIds,
1234		AckDeadlineSeconds: ackDeadlineSeconds,
1235	}
1236
1237	c, err := NewSubscriberClient(context.Background(), clientOpt)
1238	if err != nil {
1239		t.Fatal(err)
1240	}
1241
1242	err = c.ModifyAckDeadline(context.Background(), request)
1243
1244	if st, ok := gstatus.FromError(err); !ok {
1245		t.Errorf("got error %v, expected grpc error", err)
1246	} else if c := st.Code(); c != errCode {
1247		t.Errorf("got error code %q, want %q", c, errCode)
1248	}
1249}
1250func TestSubscriberAcknowledge(t *testing.T) {
1251	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1252
1253	mockSubscriber.err = nil
1254	mockSubscriber.reqs = nil
1255
1256	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1257
1258	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1259	var ackIds []string = nil
1260	var request = &pubsubpb.AcknowledgeRequest{
1261		Subscription: formattedSubscription,
1262		AckIds:       ackIds,
1263	}
1264
1265	c, err := NewSubscriberClient(context.Background(), clientOpt)
1266	if err != nil {
1267		t.Fatal(err)
1268	}
1269
1270	err = c.Acknowledge(context.Background(), request)
1271
1272	if err != nil {
1273		t.Fatal(err)
1274	}
1275
1276	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1277		t.Errorf("wrong request %q, want %q", got, want)
1278	}
1279
1280}
1281
1282func TestSubscriberAcknowledgeError(t *testing.T) {
1283	errCode := codes.PermissionDenied
1284	mockSubscriber.err = gstatus.Error(errCode, "test error")
1285
1286	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1287	var ackIds []string = nil
1288	var request = &pubsubpb.AcknowledgeRequest{
1289		Subscription: formattedSubscription,
1290		AckIds:       ackIds,
1291	}
1292
1293	c, err := NewSubscriberClient(context.Background(), clientOpt)
1294	if err != nil {
1295		t.Fatal(err)
1296	}
1297
1298	err = c.Acknowledge(context.Background(), request)
1299
1300	if st, ok := gstatus.FromError(err); !ok {
1301		t.Errorf("got error %v, expected grpc error", err)
1302	} else if c := st.Code(); c != errCode {
1303		t.Errorf("got error code %q, want %q", c, errCode)
1304	}
1305}
1306func TestSubscriberPull(t *testing.T) {
1307	var expectedResponse *pubsubpb.PullResponse = &pubsubpb.PullResponse{}
1308
1309	mockSubscriber.err = nil
1310	mockSubscriber.reqs = nil
1311
1312	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1313
1314	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1315	var maxMessages int32 = 496131527
1316	var request = &pubsubpb.PullRequest{
1317		Subscription: formattedSubscription,
1318		MaxMessages:  maxMessages,
1319	}
1320
1321	c, err := NewSubscriberClient(context.Background(), clientOpt)
1322	if err != nil {
1323		t.Fatal(err)
1324	}
1325
1326	resp, err := c.Pull(context.Background(), request)
1327
1328	if err != nil {
1329		t.Fatal(err)
1330	}
1331
1332	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1333		t.Errorf("wrong request %q, want %q", got, want)
1334	}
1335
1336	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1337		t.Errorf("wrong response %q, want %q)", got, want)
1338	}
1339}
1340
1341func TestSubscriberPullError(t *testing.T) {
1342	errCode := codes.PermissionDenied
1343	mockSubscriber.err = gstatus.Error(errCode, "test error")
1344
1345	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1346	var maxMessages int32 = 496131527
1347	var request = &pubsubpb.PullRequest{
1348		Subscription: formattedSubscription,
1349		MaxMessages:  maxMessages,
1350	}
1351
1352	c, err := NewSubscriberClient(context.Background(), clientOpt)
1353	if err != nil {
1354		t.Fatal(err)
1355	}
1356
1357	resp, err := c.Pull(context.Background(), request)
1358
1359	if st, ok := gstatus.FromError(err); !ok {
1360		t.Errorf("got error %v, expected grpc error", err)
1361	} else if c := st.Code(); c != errCode {
1362		t.Errorf("got error code %q, want %q", c, errCode)
1363	}
1364	_ = resp
1365}
1366func TestSubscriberStreamingPull(t *testing.T) {
1367	var receivedMessagesElement *pubsubpb.ReceivedMessage = &pubsubpb.ReceivedMessage{}
1368	var receivedMessages = []*pubsubpb.ReceivedMessage{receivedMessagesElement}
1369	var expectedResponse = &pubsubpb.StreamingPullResponse{
1370		ReceivedMessages: receivedMessages,
1371	}
1372
1373	mockSubscriber.err = nil
1374	mockSubscriber.reqs = nil
1375
1376	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1377
1378	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1379	var streamAckDeadlineSeconds int32 = 1875467245
1380	var request = &pubsubpb.StreamingPullRequest{
1381		Subscription:             formattedSubscription,
1382		StreamAckDeadlineSeconds: streamAckDeadlineSeconds,
1383	}
1384
1385	c, err := NewSubscriberClient(context.Background(), clientOpt)
1386	if err != nil {
1387		t.Fatal(err)
1388	}
1389
1390	stream, err := c.StreamingPull(context.Background())
1391	if err != nil {
1392		t.Fatal(err)
1393	}
1394	if err := stream.Send(request); err != nil {
1395		t.Fatal(err)
1396	}
1397	if err := stream.CloseSend(); err != nil {
1398		t.Fatal(err)
1399	}
1400	resp, err := stream.Recv()
1401
1402	if err != nil {
1403		t.Fatal(err)
1404	}
1405
1406	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1407		t.Errorf("wrong request %q, want %q", got, want)
1408	}
1409
1410	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1411		t.Errorf("wrong response %q, want %q)", got, want)
1412	}
1413}
1414
1415func TestSubscriberStreamingPullError(t *testing.T) {
1416	errCode := codes.PermissionDenied
1417	mockSubscriber.err = gstatus.Error(errCode, "test error")
1418
1419	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1420	var streamAckDeadlineSeconds int32 = 1875467245
1421	var request = &pubsubpb.StreamingPullRequest{
1422		Subscription:             formattedSubscription,
1423		StreamAckDeadlineSeconds: streamAckDeadlineSeconds,
1424	}
1425
1426	c, err := NewSubscriberClient(context.Background(), clientOpt)
1427	if err != nil {
1428		t.Fatal(err)
1429	}
1430
1431	stream, err := c.StreamingPull(context.Background())
1432	if err != nil {
1433		t.Fatal(err)
1434	}
1435	if err := stream.Send(request); err != nil {
1436		t.Fatal(err)
1437	}
1438	if err := stream.CloseSend(); err != nil {
1439		t.Fatal(err)
1440	}
1441	resp, err := stream.Recv()
1442
1443	if st, ok := gstatus.FromError(err); !ok {
1444		t.Errorf("got error %v, expected grpc error", err)
1445	} else if c := st.Code(); c != errCode {
1446		t.Errorf("got error code %q, want %q", c, errCode)
1447	}
1448	_ = resp
1449}
1450func TestSubscriberModifyPushConfig(t *testing.T) {
1451	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1452
1453	mockSubscriber.err = nil
1454	mockSubscriber.reqs = nil
1455
1456	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1457
1458	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1459	var pushConfig *pubsubpb.PushConfig = &pubsubpb.PushConfig{}
1460	var request = &pubsubpb.ModifyPushConfigRequest{
1461		Subscription: formattedSubscription,
1462		PushConfig:   pushConfig,
1463	}
1464
1465	c, err := NewSubscriberClient(context.Background(), clientOpt)
1466	if err != nil {
1467		t.Fatal(err)
1468	}
1469
1470	err = c.ModifyPushConfig(context.Background(), request)
1471
1472	if err != nil {
1473		t.Fatal(err)
1474	}
1475
1476	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1477		t.Errorf("wrong request %q, want %q", got, want)
1478	}
1479
1480}
1481
1482func TestSubscriberModifyPushConfigError(t *testing.T) {
1483	errCode := codes.PermissionDenied
1484	mockSubscriber.err = gstatus.Error(errCode, "test error")
1485
1486	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1487	var pushConfig *pubsubpb.PushConfig = &pubsubpb.PushConfig{}
1488	var request = &pubsubpb.ModifyPushConfigRequest{
1489		Subscription: formattedSubscription,
1490		PushConfig:   pushConfig,
1491	}
1492
1493	c, err := NewSubscriberClient(context.Background(), clientOpt)
1494	if err != nil {
1495		t.Fatal(err)
1496	}
1497
1498	err = c.ModifyPushConfig(context.Background(), request)
1499
1500	if st, ok := gstatus.FromError(err); !ok {
1501		t.Errorf("got error %v, expected grpc error", err)
1502	} else if c := st.Code(); c != errCode {
1503		t.Errorf("got error code %q, want %q", c, errCode)
1504	}
1505}
1506func TestSubscriberListSnapshots(t *testing.T) {
1507	var nextPageToken string = ""
1508	var snapshotsElement *pubsubpb.Snapshot = &pubsubpb.Snapshot{}
1509	var snapshots = []*pubsubpb.Snapshot{snapshotsElement}
1510	var expectedResponse = &pubsubpb.ListSnapshotsResponse{
1511		NextPageToken: nextPageToken,
1512		Snapshots:     snapshots,
1513	}
1514
1515	mockSubscriber.err = nil
1516	mockSubscriber.reqs = nil
1517
1518	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1519
1520	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
1521	var request = &pubsubpb.ListSnapshotsRequest{
1522		Project: formattedProject,
1523	}
1524
1525	c, err := NewSubscriberClient(context.Background(), clientOpt)
1526	if err != nil {
1527		t.Fatal(err)
1528	}
1529
1530	resp, err := c.ListSnapshots(context.Background(), request).Next()
1531
1532	if err != nil {
1533		t.Fatal(err)
1534	}
1535
1536	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1537		t.Errorf("wrong request %q, want %q", got, want)
1538	}
1539
1540	want := (interface{})(expectedResponse.Snapshots[0])
1541	got := (interface{})(resp)
1542	var ok bool
1543
1544	switch want := (want).(type) {
1545	case proto.Message:
1546		ok = proto.Equal(want, got.(proto.Message))
1547	default:
1548		ok = want == got
1549	}
1550	if !ok {
1551		t.Errorf("wrong response %q, want %q)", got, want)
1552	}
1553}
1554
1555func TestSubscriberListSnapshotsError(t *testing.T) {
1556	errCode := codes.PermissionDenied
1557	mockSubscriber.err = gstatus.Error(errCode, "test error")
1558
1559	var formattedProject string = fmt.Sprintf("projects/%s", "[PROJECT]")
1560	var request = &pubsubpb.ListSnapshotsRequest{
1561		Project: formattedProject,
1562	}
1563
1564	c, err := NewSubscriberClient(context.Background(), clientOpt)
1565	if err != nil {
1566		t.Fatal(err)
1567	}
1568
1569	resp, err := c.ListSnapshots(context.Background(), request).Next()
1570
1571	if st, ok := gstatus.FromError(err); !ok {
1572		t.Errorf("got error %v, expected grpc error", err)
1573	} else if c := st.Code(); c != errCode {
1574		t.Errorf("got error code %q, want %q", c, errCode)
1575	}
1576	_ = resp
1577}
1578func TestSubscriberCreateSnapshot(t *testing.T) {
1579	var name2 string = "name2-1052831874"
1580	var topic string = "topic110546223"
1581	var expectedResponse = &pubsubpb.Snapshot{
1582		Name:  name2,
1583		Topic: topic,
1584	}
1585
1586	mockSubscriber.err = nil
1587	mockSubscriber.reqs = nil
1588
1589	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1590
1591	var formattedName string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]")
1592	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1593	var request = &pubsubpb.CreateSnapshotRequest{
1594		Name:         formattedName,
1595		Subscription: formattedSubscription,
1596	}
1597
1598	c, err := NewSubscriberClient(context.Background(), clientOpt)
1599	if err != nil {
1600		t.Fatal(err)
1601	}
1602
1603	resp, err := c.CreateSnapshot(context.Background(), request)
1604
1605	if err != nil {
1606		t.Fatal(err)
1607	}
1608
1609	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1610		t.Errorf("wrong request %q, want %q", got, want)
1611	}
1612
1613	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1614		t.Errorf("wrong response %q, want %q)", got, want)
1615	}
1616}
1617
1618func TestSubscriberCreateSnapshotError(t *testing.T) {
1619	errCode := codes.PermissionDenied
1620	mockSubscriber.err = gstatus.Error(errCode, "test error")
1621
1622	var formattedName string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]")
1623	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1624	var request = &pubsubpb.CreateSnapshotRequest{
1625		Name:         formattedName,
1626		Subscription: formattedSubscription,
1627	}
1628
1629	c, err := NewSubscriberClient(context.Background(), clientOpt)
1630	if err != nil {
1631		t.Fatal(err)
1632	}
1633
1634	resp, err := c.CreateSnapshot(context.Background(), request)
1635
1636	if st, ok := gstatus.FromError(err); !ok {
1637		t.Errorf("got error %v, expected grpc error", err)
1638	} else if c := st.Code(); c != errCode {
1639		t.Errorf("got error code %q, want %q", c, errCode)
1640	}
1641	_ = resp
1642}
1643func TestSubscriberUpdateSnapshot(t *testing.T) {
1644	var name string = "name3373707"
1645	var topic string = "topic110546223"
1646	var expectedResponse = &pubsubpb.Snapshot{
1647		Name:  name,
1648		Topic: topic,
1649	}
1650
1651	mockSubscriber.err = nil
1652	mockSubscriber.reqs = nil
1653
1654	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1655
1656	var seconds int64 = 123456
1657	var expireTime = &timestamppb.Timestamp{
1658		Seconds: seconds,
1659	}
1660	var snapshot = &pubsubpb.Snapshot{
1661		ExpireTime: expireTime,
1662	}
1663	var pathsElement string = "expire_time"
1664	var paths = []string{pathsElement}
1665	var updateMask = &field_maskpb.FieldMask{
1666		Paths: paths,
1667	}
1668	var request = &pubsubpb.UpdateSnapshotRequest{
1669		Snapshot:   snapshot,
1670		UpdateMask: updateMask,
1671	}
1672
1673	c, err := NewSubscriberClient(context.Background(), clientOpt)
1674	if err != nil {
1675		t.Fatal(err)
1676	}
1677
1678	resp, err := c.UpdateSnapshot(context.Background(), request)
1679
1680	if err != nil {
1681		t.Fatal(err)
1682	}
1683
1684	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1685		t.Errorf("wrong request %q, want %q", got, want)
1686	}
1687
1688	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1689		t.Errorf("wrong response %q, want %q)", got, want)
1690	}
1691}
1692
1693func TestSubscriberUpdateSnapshotError(t *testing.T) {
1694	errCode := codes.PermissionDenied
1695	mockSubscriber.err = gstatus.Error(errCode, "test error")
1696
1697	var seconds int64 = 123456
1698	var expireTime = &timestamppb.Timestamp{
1699		Seconds: seconds,
1700	}
1701	var snapshot = &pubsubpb.Snapshot{
1702		ExpireTime: expireTime,
1703	}
1704	var pathsElement string = "expire_time"
1705	var paths = []string{pathsElement}
1706	var updateMask = &field_maskpb.FieldMask{
1707		Paths: paths,
1708	}
1709	var request = &pubsubpb.UpdateSnapshotRequest{
1710		Snapshot:   snapshot,
1711		UpdateMask: updateMask,
1712	}
1713
1714	c, err := NewSubscriberClient(context.Background(), clientOpt)
1715	if err != nil {
1716		t.Fatal(err)
1717	}
1718
1719	resp, err := c.UpdateSnapshot(context.Background(), request)
1720
1721	if st, ok := gstatus.FromError(err); !ok {
1722		t.Errorf("got error %v, expected grpc error", err)
1723	} else if c := st.Code(); c != errCode {
1724		t.Errorf("got error code %q, want %q", c, errCode)
1725	}
1726	_ = resp
1727}
1728func TestSubscriberDeleteSnapshot(t *testing.T) {
1729	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1730
1731	mockSubscriber.err = nil
1732	mockSubscriber.reqs = nil
1733
1734	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1735
1736	var formattedSnapshot string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]")
1737	var request = &pubsubpb.DeleteSnapshotRequest{
1738		Snapshot: formattedSnapshot,
1739	}
1740
1741	c, err := NewSubscriberClient(context.Background(), clientOpt)
1742	if err != nil {
1743		t.Fatal(err)
1744	}
1745
1746	err = c.DeleteSnapshot(context.Background(), request)
1747
1748	if err != nil {
1749		t.Fatal(err)
1750	}
1751
1752	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1753		t.Errorf("wrong request %q, want %q", got, want)
1754	}
1755
1756}
1757
1758func TestSubscriberDeleteSnapshotError(t *testing.T) {
1759	errCode := codes.PermissionDenied
1760	mockSubscriber.err = gstatus.Error(errCode, "test error")
1761
1762	var formattedSnapshot string = fmt.Sprintf("projects/%s/snapshots/%s", "[PROJECT]", "[SNAPSHOT]")
1763	var request = &pubsubpb.DeleteSnapshotRequest{
1764		Snapshot: formattedSnapshot,
1765	}
1766
1767	c, err := NewSubscriberClient(context.Background(), clientOpt)
1768	if err != nil {
1769		t.Fatal(err)
1770	}
1771
1772	err = c.DeleteSnapshot(context.Background(), request)
1773
1774	if st, ok := gstatus.FromError(err); !ok {
1775		t.Errorf("got error %v, expected grpc error", err)
1776	} else if c := st.Code(); c != errCode {
1777		t.Errorf("got error code %q, want %q", c, errCode)
1778	}
1779}
1780func TestSubscriberSeek(t *testing.T) {
1781	var expectedResponse *pubsubpb.SeekResponse = &pubsubpb.SeekResponse{}
1782
1783	mockSubscriber.err = nil
1784	mockSubscriber.reqs = nil
1785
1786	mockSubscriber.resps = append(mockSubscriber.resps[:0], expectedResponse)
1787
1788	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1789	var request = &pubsubpb.SeekRequest{
1790		Subscription: formattedSubscription,
1791	}
1792
1793	c, err := NewSubscriberClient(context.Background(), clientOpt)
1794	if err != nil {
1795		t.Fatal(err)
1796	}
1797
1798	resp, err := c.Seek(context.Background(), request)
1799
1800	if err != nil {
1801		t.Fatal(err)
1802	}
1803
1804	if want, got := request, mockSubscriber.reqs[0]; !proto.Equal(want, got) {
1805		t.Errorf("wrong request %q, want %q", got, want)
1806	}
1807
1808	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1809		t.Errorf("wrong response %q, want %q)", got, want)
1810	}
1811}
1812
1813func TestSubscriberSeekError(t *testing.T) {
1814	errCode := codes.PermissionDenied
1815	mockSubscriber.err = gstatus.Error(errCode, "test error")
1816
1817	var formattedSubscription string = fmt.Sprintf("projects/%s/subscriptions/%s", "[PROJECT]", "[SUBSCRIPTION]")
1818	var request = &pubsubpb.SeekRequest{
1819		Subscription: formattedSubscription,
1820	}
1821
1822	c, err := NewSubscriberClient(context.Background(), clientOpt)
1823	if err != nil {
1824		t.Fatal(err)
1825	}
1826
1827	resp, err := c.Seek(context.Background(), request)
1828
1829	if st, ok := gstatus.FromError(err); !ok {
1830		t.Errorf("got error %v, expected grpc error", err)
1831	} else if c := st.Code(); c != errCode {
1832		t.Errorf("got error code %q, want %q", c, errCode)
1833	}
1834	_ = resp
1835}
1836