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