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 monitoring
18
19import (
20	"context"
21	"flag"
22	"fmt"
23	"io"
24	"log"
25	"net"
26	"os"
27	"strings"
28	"testing"
29
30	"github.com/golang/protobuf/proto"
31	"github.com/golang/protobuf/ptypes"
32	emptypb "github.com/golang/protobuf/ptypes/empty"
33	"google.golang.org/api/option"
34	metricpb "google.golang.org/genproto/googleapis/api/metric"
35	monitoredrespb "google.golang.org/genproto/googleapis/api/monitoredres"
36	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
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 mockAlertPolicyServer struct {
51	// Embed for forward compatibility.
52	// Tests will keep working if more methods are added
53	// in the future.
54	monitoringpb.AlertPolicyServiceServer
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 *mockAlertPolicyServer) ListAlertPolicies(ctx context.Context, req *monitoringpb.ListAlertPoliciesRequest) (*monitoringpb.ListAlertPoliciesResponse, 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].(*monitoringpb.ListAlertPoliciesResponse), nil
75}
76
77func (s *mockAlertPolicyServer) GetAlertPolicy(ctx context.Context, req *monitoringpb.GetAlertPolicyRequest) (*monitoringpb.AlertPolicy, 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].(*monitoringpb.AlertPolicy), nil
87}
88
89func (s *mockAlertPolicyServer) CreateAlertPolicy(ctx context.Context, req *monitoringpb.CreateAlertPolicyRequest) (*monitoringpb.AlertPolicy, 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].(*monitoringpb.AlertPolicy), nil
99}
100
101func (s *mockAlertPolicyServer) DeleteAlertPolicy(ctx context.Context, req *monitoringpb.DeleteAlertPolicyRequest) (*emptypb.Empty, 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].(*emptypb.Empty), nil
111}
112
113func (s *mockAlertPolicyServer) UpdateAlertPolicy(ctx context.Context, req *monitoringpb.UpdateAlertPolicyRequest) (*monitoringpb.AlertPolicy, 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].(*monitoringpb.AlertPolicy), nil
123}
124
125type mockGroupServer struct {
126	// Embed for forward compatibility.
127	// Tests will keep working if more methods are added
128	// in the future.
129	monitoringpb.GroupServiceServer
130
131	reqs []proto.Message
132
133	// If set, all calls return this error.
134	err error
135
136	// responses to return if err == nil
137	resps []proto.Message
138}
139
140func (s *mockGroupServer) ListGroups(ctx context.Context, req *monitoringpb.ListGroupsRequest) (*monitoringpb.ListGroupsResponse, error) {
141	md, _ := metadata.FromIncomingContext(ctx)
142	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
143		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
144	}
145	s.reqs = append(s.reqs, req)
146	if s.err != nil {
147		return nil, s.err
148	}
149	return s.resps[0].(*monitoringpb.ListGroupsResponse), nil
150}
151
152func (s *mockGroupServer) GetGroup(ctx context.Context, req *monitoringpb.GetGroupRequest) (*monitoringpb.Group, error) {
153	md, _ := metadata.FromIncomingContext(ctx)
154	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
155		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
156	}
157	s.reqs = append(s.reqs, req)
158	if s.err != nil {
159		return nil, s.err
160	}
161	return s.resps[0].(*monitoringpb.Group), nil
162}
163
164func (s *mockGroupServer) CreateGroup(ctx context.Context, req *monitoringpb.CreateGroupRequest) (*monitoringpb.Group, 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].(*monitoringpb.Group), nil
174}
175
176func (s *mockGroupServer) UpdateGroup(ctx context.Context, req *monitoringpb.UpdateGroupRequest) (*monitoringpb.Group, 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].(*monitoringpb.Group), nil
186}
187
188func (s *mockGroupServer) DeleteGroup(ctx context.Context, req *monitoringpb.DeleteGroupRequest) (*emptypb.Empty, 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].(*emptypb.Empty), nil
198}
199
200func (s *mockGroupServer) ListGroupMembers(ctx context.Context, req *monitoringpb.ListGroupMembersRequest) (*monitoringpb.ListGroupMembersResponse, 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].(*monitoringpb.ListGroupMembersResponse), nil
210}
211
212type mockMetricServer struct {
213	// Embed for forward compatibility.
214	// Tests will keep working if more methods are added
215	// in the future.
216	monitoringpb.MetricServiceServer
217
218	reqs []proto.Message
219
220	// If set, all calls return this error.
221	err error
222
223	// responses to return if err == nil
224	resps []proto.Message
225}
226
227func (s *mockMetricServer) ListMonitoredResourceDescriptors(ctx context.Context, req *monitoringpb.ListMonitoredResourceDescriptorsRequest) (*monitoringpb.ListMonitoredResourceDescriptorsResponse, error) {
228	md, _ := metadata.FromIncomingContext(ctx)
229	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
230		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
231	}
232	s.reqs = append(s.reqs, req)
233	if s.err != nil {
234		return nil, s.err
235	}
236	return s.resps[0].(*monitoringpb.ListMonitoredResourceDescriptorsResponse), nil
237}
238
239func (s *mockMetricServer) GetMonitoredResourceDescriptor(ctx context.Context, req *monitoringpb.GetMonitoredResourceDescriptorRequest) (*monitoredrespb.MonitoredResourceDescriptor, error) {
240	md, _ := metadata.FromIncomingContext(ctx)
241	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
242		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
243	}
244	s.reqs = append(s.reqs, req)
245	if s.err != nil {
246		return nil, s.err
247	}
248	return s.resps[0].(*monitoredrespb.MonitoredResourceDescriptor), nil
249}
250
251func (s *mockMetricServer) ListMetricDescriptors(ctx context.Context, req *monitoringpb.ListMetricDescriptorsRequest) (*monitoringpb.ListMetricDescriptorsResponse, error) {
252	md, _ := metadata.FromIncomingContext(ctx)
253	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
254		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
255	}
256	s.reqs = append(s.reqs, req)
257	if s.err != nil {
258		return nil, s.err
259	}
260	return s.resps[0].(*monitoringpb.ListMetricDescriptorsResponse), nil
261}
262
263func (s *mockMetricServer) GetMetricDescriptor(ctx context.Context, req *monitoringpb.GetMetricDescriptorRequest) (*metricpb.MetricDescriptor, error) {
264	md, _ := metadata.FromIncomingContext(ctx)
265	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
266		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
267	}
268	s.reqs = append(s.reqs, req)
269	if s.err != nil {
270		return nil, s.err
271	}
272	return s.resps[0].(*metricpb.MetricDescriptor), nil
273}
274
275func (s *mockMetricServer) CreateMetricDescriptor(ctx context.Context, req *monitoringpb.CreateMetricDescriptorRequest) (*metricpb.MetricDescriptor, error) {
276	md, _ := metadata.FromIncomingContext(ctx)
277	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
278		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
279	}
280	s.reqs = append(s.reqs, req)
281	if s.err != nil {
282		return nil, s.err
283	}
284	return s.resps[0].(*metricpb.MetricDescriptor), nil
285}
286
287func (s *mockMetricServer) DeleteMetricDescriptor(ctx context.Context, req *monitoringpb.DeleteMetricDescriptorRequest) (*emptypb.Empty, error) {
288	md, _ := metadata.FromIncomingContext(ctx)
289	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
290		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
291	}
292	s.reqs = append(s.reqs, req)
293	if s.err != nil {
294		return nil, s.err
295	}
296	return s.resps[0].(*emptypb.Empty), nil
297}
298
299func (s *mockMetricServer) ListTimeSeries(ctx context.Context, req *monitoringpb.ListTimeSeriesRequest) (*monitoringpb.ListTimeSeriesResponse, error) {
300	md, _ := metadata.FromIncomingContext(ctx)
301	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
302		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
303	}
304	s.reqs = append(s.reqs, req)
305	if s.err != nil {
306		return nil, s.err
307	}
308	return s.resps[0].(*monitoringpb.ListTimeSeriesResponse), nil
309}
310
311func (s *mockMetricServer) CreateTimeSeries(ctx context.Context, req *monitoringpb.CreateTimeSeriesRequest) (*emptypb.Empty, error) {
312	md, _ := metadata.FromIncomingContext(ctx)
313	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
314		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
315	}
316	s.reqs = append(s.reqs, req)
317	if s.err != nil {
318		return nil, s.err
319	}
320	return s.resps[0].(*emptypb.Empty), nil
321}
322
323type mockNotificationChannelServer struct {
324	// Embed for forward compatibility.
325	// Tests will keep working if more methods are added
326	// in the future.
327	monitoringpb.NotificationChannelServiceServer
328
329	reqs []proto.Message
330
331	// If set, all calls return this error.
332	err error
333
334	// responses to return if err == nil
335	resps []proto.Message
336}
337
338func (s *mockNotificationChannelServer) ListNotificationChannelDescriptors(ctx context.Context, req *monitoringpb.ListNotificationChannelDescriptorsRequest) (*monitoringpb.ListNotificationChannelDescriptorsResponse, error) {
339	md, _ := metadata.FromIncomingContext(ctx)
340	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
341		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
342	}
343	s.reqs = append(s.reqs, req)
344	if s.err != nil {
345		return nil, s.err
346	}
347	return s.resps[0].(*monitoringpb.ListNotificationChannelDescriptorsResponse), nil
348}
349
350func (s *mockNotificationChannelServer) GetNotificationChannelDescriptor(ctx context.Context, req *monitoringpb.GetNotificationChannelDescriptorRequest) (*monitoringpb.NotificationChannelDescriptor, error) {
351	md, _ := metadata.FromIncomingContext(ctx)
352	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
353		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
354	}
355	s.reqs = append(s.reqs, req)
356	if s.err != nil {
357		return nil, s.err
358	}
359	return s.resps[0].(*monitoringpb.NotificationChannelDescriptor), nil
360}
361
362func (s *mockNotificationChannelServer) ListNotificationChannels(ctx context.Context, req *monitoringpb.ListNotificationChannelsRequest) (*monitoringpb.ListNotificationChannelsResponse, error) {
363	md, _ := metadata.FromIncomingContext(ctx)
364	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
365		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
366	}
367	s.reqs = append(s.reqs, req)
368	if s.err != nil {
369		return nil, s.err
370	}
371	return s.resps[0].(*monitoringpb.ListNotificationChannelsResponse), nil
372}
373
374func (s *mockNotificationChannelServer) GetNotificationChannel(ctx context.Context, req *monitoringpb.GetNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
375	md, _ := metadata.FromIncomingContext(ctx)
376	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
377		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
378	}
379	s.reqs = append(s.reqs, req)
380	if s.err != nil {
381		return nil, s.err
382	}
383	return s.resps[0].(*monitoringpb.NotificationChannel), nil
384}
385
386func (s *mockNotificationChannelServer) CreateNotificationChannel(ctx context.Context, req *monitoringpb.CreateNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
387	md, _ := metadata.FromIncomingContext(ctx)
388	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
389		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
390	}
391	s.reqs = append(s.reqs, req)
392	if s.err != nil {
393		return nil, s.err
394	}
395	return s.resps[0].(*monitoringpb.NotificationChannel), nil
396}
397
398func (s *mockNotificationChannelServer) UpdateNotificationChannel(ctx context.Context, req *monitoringpb.UpdateNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
399	md, _ := metadata.FromIncomingContext(ctx)
400	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
401		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
402	}
403	s.reqs = append(s.reqs, req)
404	if s.err != nil {
405		return nil, s.err
406	}
407	return s.resps[0].(*monitoringpb.NotificationChannel), nil
408}
409
410func (s *mockNotificationChannelServer) DeleteNotificationChannel(ctx context.Context, req *monitoringpb.DeleteNotificationChannelRequest) (*emptypb.Empty, error) {
411	md, _ := metadata.FromIncomingContext(ctx)
412	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
413		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
414	}
415	s.reqs = append(s.reqs, req)
416	if s.err != nil {
417		return nil, s.err
418	}
419	return s.resps[0].(*emptypb.Empty), nil
420}
421
422func (s *mockNotificationChannelServer) SendNotificationChannelVerificationCode(ctx context.Context, req *monitoringpb.SendNotificationChannelVerificationCodeRequest) (*emptypb.Empty, error) {
423	md, _ := metadata.FromIncomingContext(ctx)
424	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
425		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
426	}
427	s.reqs = append(s.reqs, req)
428	if s.err != nil {
429		return nil, s.err
430	}
431	return s.resps[0].(*emptypb.Empty), nil
432}
433
434func (s *mockNotificationChannelServer) GetNotificationChannelVerificationCode(ctx context.Context, req *monitoringpb.GetNotificationChannelVerificationCodeRequest) (*monitoringpb.GetNotificationChannelVerificationCodeResponse, error) {
435	md, _ := metadata.FromIncomingContext(ctx)
436	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
437		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
438	}
439	s.reqs = append(s.reqs, req)
440	if s.err != nil {
441		return nil, s.err
442	}
443	return s.resps[0].(*monitoringpb.GetNotificationChannelVerificationCodeResponse), nil
444}
445
446func (s *mockNotificationChannelServer) VerifyNotificationChannel(ctx context.Context, req *monitoringpb.VerifyNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
447	md, _ := metadata.FromIncomingContext(ctx)
448	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
449		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
450	}
451	s.reqs = append(s.reqs, req)
452	if s.err != nil {
453		return nil, s.err
454	}
455	return s.resps[0].(*monitoringpb.NotificationChannel), nil
456}
457
458type mockServiceMonitoringServer struct {
459	// Embed for forward compatibility.
460	// Tests will keep working if more methods are added
461	// in the future.
462	monitoringpb.ServiceMonitoringServiceServer
463
464	reqs []proto.Message
465
466	// If set, all calls return this error.
467	err error
468
469	// responses to return if err == nil
470	resps []proto.Message
471}
472
473func (s *mockServiceMonitoringServer) CreateService(ctx context.Context, req *monitoringpb.CreateServiceRequest) (*monitoringpb.Service, error) {
474	md, _ := metadata.FromIncomingContext(ctx)
475	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
476		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
477	}
478	s.reqs = append(s.reqs, req)
479	if s.err != nil {
480		return nil, s.err
481	}
482	return s.resps[0].(*monitoringpb.Service), nil
483}
484
485func (s *mockServiceMonitoringServer) GetService(ctx context.Context, req *monitoringpb.GetServiceRequest) (*monitoringpb.Service, error) {
486	md, _ := metadata.FromIncomingContext(ctx)
487	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
488		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
489	}
490	s.reqs = append(s.reqs, req)
491	if s.err != nil {
492		return nil, s.err
493	}
494	return s.resps[0].(*monitoringpb.Service), nil
495}
496
497func (s *mockServiceMonitoringServer) ListServices(ctx context.Context, req *monitoringpb.ListServicesRequest) (*monitoringpb.ListServicesResponse, error) {
498	md, _ := metadata.FromIncomingContext(ctx)
499	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
500		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
501	}
502	s.reqs = append(s.reqs, req)
503	if s.err != nil {
504		return nil, s.err
505	}
506	return s.resps[0].(*monitoringpb.ListServicesResponse), nil
507}
508
509func (s *mockServiceMonitoringServer) UpdateService(ctx context.Context, req *monitoringpb.UpdateServiceRequest) (*monitoringpb.Service, error) {
510	md, _ := metadata.FromIncomingContext(ctx)
511	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
512		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
513	}
514	s.reqs = append(s.reqs, req)
515	if s.err != nil {
516		return nil, s.err
517	}
518	return s.resps[0].(*monitoringpb.Service), nil
519}
520
521func (s *mockServiceMonitoringServer) DeleteService(ctx context.Context, req *monitoringpb.DeleteServiceRequest) (*emptypb.Empty, error) {
522	md, _ := metadata.FromIncomingContext(ctx)
523	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
524		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
525	}
526	s.reqs = append(s.reqs, req)
527	if s.err != nil {
528		return nil, s.err
529	}
530	return s.resps[0].(*emptypb.Empty), nil
531}
532
533func (s *mockServiceMonitoringServer) CreateServiceLevelObjective(ctx context.Context, req *monitoringpb.CreateServiceLevelObjectiveRequest) (*monitoringpb.ServiceLevelObjective, error) {
534	md, _ := metadata.FromIncomingContext(ctx)
535	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
536		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
537	}
538	s.reqs = append(s.reqs, req)
539	if s.err != nil {
540		return nil, s.err
541	}
542	return s.resps[0].(*monitoringpb.ServiceLevelObjective), nil
543}
544
545func (s *mockServiceMonitoringServer) GetServiceLevelObjective(ctx context.Context, req *monitoringpb.GetServiceLevelObjectiveRequest) (*monitoringpb.ServiceLevelObjective, error) {
546	md, _ := metadata.FromIncomingContext(ctx)
547	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
548		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
549	}
550	s.reqs = append(s.reqs, req)
551	if s.err != nil {
552		return nil, s.err
553	}
554	return s.resps[0].(*monitoringpb.ServiceLevelObjective), nil
555}
556
557func (s *mockServiceMonitoringServer) ListServiceLevelObjectives(ctx context.Context, req *monitoringpb.ListServiceLevelObjectivesRequest) (*monitoringpb.ListServiceLevelObjectivesResponse, error) {
558	md, _ := metadata.FromIncomingContext(ctx)
559	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
560		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
561	}
562	s.reqs = append(s.reqs, req)
563	if s.err != nil {
564		return nil, s.err
565	}
566	return s.resps[0].(*monitoringpb.ListServiceLevelObjectivesResponse), nil
567}
568
569func (s *mockServiceMonitoringServer) UpdateServiceLevelObjective(ctx context.Context, req *monitoringpb.UpdateServiceLevelObjectiveRequest) (*monitoringpb.ServiceLevelObjective, error) {
570	md, _ := metadata.FromIncomingContext(ctx)
571	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
572		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
573	}
574	s.reqs = append(s.reqs, req)
575	if s.err != nil {
576		return nil, s.err
577	}
578	return s.resps[0].(*monitoringpb.ServiceLevelObjective), nil
579}
580
581func (s *mockServiceMonitoringServer) DeleteServiceLevelObjective(ctx context.Context, req *monitoringpb.DeleteServiceLevelObjectiveRequest) (*emptypb.Empty, error) {
582	md, _ := metadata.FromIncomingContext(ctx)
583	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
584		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
585	}
586	s.reqs = append(s.reqs, req)
587	if s.err != nil {
588		return nil, s.err
589	}
590	return s.resps[0].(*emptypb.Empty), nil
591}
592
593type mockUptimeCheckServer struct {
594	// Embed for forward compatibility.
595	// Tests will keep working if more methods are added
596	// in the future.
597	monitoringpb.UptimeCheckServiceServer
598
599	reqs []proto.Message
600
601	// If set, all calls return this error.
602	err error
603
604	// responses to return if err == nil
605	resps []proto.Message
606}
607
608func (s *mockUptimeCheckServer) ListUptimeCheckConfigs(ctx context.Context, req *monitoringpb.ListUptimeCheckConfigsRequest) (*monitoringpb.ListUptimeCheckConfigsResponse, error) {
609	md, _ := metadata.FromIncomingContext(ctx)
610	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
611		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
612	}
613	s.reqs = append(s.reqs, req)
614	if s.err != nil {
615		return nil, s.err
616	}
617	return s.resps[0].(*monitoringpb.ListUptimeCheckConfigsResponse), nil
618}
619
620func (s *mockUptimeCheckServer) GetUptimeCheckConfig(ctx context.Context, req *monitoringpb.GetUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
621	md, _ := metadata.FromIncomingContext(ctx)
622	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
623		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
624	}
625	s.reqs = append(s.reqs, req)
626	if s.err != nil {
627		return nil, s.err
628	}
629	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
630}
631
632func (s *mockUptimeCheckServer) CreateUptimeCheckConfig(ctx context.Context, req *monitoringpb.CreateUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
633	md, _ := metadata.FromIncomingContext(ctx)
634	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
635		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
636	}
637	s.reqs = append(s.reqs, req)
638	if s.err != nil {
639		return nil, s.err
640	}
641	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
642}
643
644func (s *mockUptimeCheckServer) UpdateUptimeCheckConfig(ctx context.Context, req *monitoringpb.UpdateUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
645	md, _ := metadata.FromIncomingContext(ctx)
646	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
647		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
648	}
649	s.reqs = append(s.reqs, req)
650	if s.err != nil {
651		return nil, s.err
652	}
653	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
654}
655
656func (s *mockUptimeCheckServer) DeleteUptimeCheckConfig(ctx context.Context, req *monitoringpb.DeleteUptimeCheckConfigRequest) (*emptypb.Empty, error) {
657	md, _ := metadata.FromIncomingContext(ctx)
658	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
659		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
660	}
661	s.reqs = append(s.reqs, req)
662	if s.err != nil {
663		return nil, s.err
664	}
665	return s.resps[0].(*emptypb.Empty), nil
666}
667
668func (s *mockUptimeCheckServer) ListUptimeCheckIps(ctx context.Context, req *monitoringpb.ListUptimeCheckIpsRequest) (*monitoringpb.ListUptimeCheckIpsResponse, error) {
669	md, _ := metadata.FromIncomingContext(ctx)
670	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
671		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
672	}
673	s.reqs = append(s.reqs, req)
674	if s.err != nil {
675		return nil, s.err
676	}
677	return s.resps[0].(*monitoringpb.ListUptimeCheckIpsResponse), nil
678}
679
680// clientOpt is the option tests should use to connect to the test server.
681// It is initialized by TestMain.
682var clientOpt option.ClientOption
683
684var (
685	mockAlertPolicy         mockAlertPolicyServer
686	mockGroup               mockGroupServer
687	mockMetric              mockMetricServer
688	mockNotificationChannel mockNotificationChannelServer
689	mockServiceMonitoring   mockServiceMonitoringServer
690	mockUptimeCheck         mockUptimeCheckServer
691)
692
693func TestMain(m *testing.M) {
694	flag.Parse()
695
696	serv := grpc.NewServer()
697	monitoringpb.RegisterAlertPolicyServiceServer(serv, &mockAlertPolicy)
698	monitoringpb.RegisterGroupServiceServer(serv, &mockGroup)
699	monitoringpb.RegisterMetricServiceServer(serv, &mockMetric)
700	monitoringpb.RegisterNotificationChannelServiceServer(serv, &mockNotificationChannel)
701	monitoringpb.RegisterServiceMonitoringServiceServer(serv, &mockServiceMonitoring)
702	monitoringpb.RegisterUptimeCheckServiceServer(serv, &mockUptimeCheck)
703
704	lis, err := net.Listen("tcp", "localhost:0")
705	if err != nil {
706		log.Fatal(err)
707	}
708	go serv.Serve(lis)
709
710	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
711	if err != nil {
712		log.Fatal(err)
713	}
714	clientOpt = option.WithGRPCConn(conn)
715
716	os.Exit(m.Run())
717}
718
719func TestAlertPolicyServiceListAlertPolicies(t *testing.T) {
720	var nextPageToken string = ""
721	var alertPoliciesElement *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
722	var alertPolicies = []*monitoringpb.AlertPolicy{alertPoliciesElement}
723	var expectedResponse = &monitoringpb.ListAlertPoliciesResponse{
724		NextPageToken: nextPageToken,
725		AlertPolicies: alertPolicies,
726	}
727
728	mockAlertPolicy.err = nil
729	mockAlertPolicy.reqs = nil
730
731	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
732
733	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
734	var request = &monitoringpb.ListAlertPoliciesRequest{
735		Name: formattedName,
736	}
737
738	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
739	if err != nil {
740		t.Fatal(err)
741	}
742
743	resp, err := c.ListAlertPolicies(context.Background(), request).Next()
744
745	if err != nil {
746		t.Fatal(err)
747	}
748
749	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
750		t.Errorf("wrong request %q, want %q", got, want)
751	}
752
753	want := (interface{})(expectedResponse.AlertPolicies[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 TestAlertPolicyServiceListAlertPoliciesError(t *testing.T) {
769	errCode := codes.PermissionDenied
770	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
771
772	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
773	var request = &monitoringpb.ListAlertPoliciesRequest{
774		Name: formattedName,
775	}
776
777	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
778	if err != nil {
779		t.Fatal(err)
780	}
781
782	resp, err := c.ListAlertPolicies(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 TestAlertPolicyServiceGetAlertPolicy(t *testing.T) {
792	var name2 string = "name2-1052831874"
793	var displayName string = "displayName1615086568"
794	var expectedResponse = &monitoringpb.AlertPolicy{
795		Name:        name2,
796		DisplayName: displayName,
797	}
798
799	mockAlertPolicy.err = nil
800	mockAlertPolicy.reqs = nil
801
802	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
803
804	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
805	var request = &monitoringpb.GetAlertPolicyRequest{
806		Name: formattedName,
807	}
808
809	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
810	if err != nil {
811		t.Fatal(err)
812	}
813
814	resp, err := c.GetAlertPolicy(context.Background(), request)
815
816	if err != nil {
817		t.Fatal(err)
818	}
819
820	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
821		t.Errorf("wrong request %q, want %q", got, want)
822	}
823
824	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
825		t.Errorf("wrong response %q, want %q)", got, want)
826	}
827}
828
829func TestAlertPolicyServiceGetAlertPolicyError(t *testing.T) {
830	errCode := codes.PermissionDenied
831	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
832
833	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
834	var request = &monitoringpb.GetAlertPolicyRequest{
835		Name: formattedName,
836	}
837
838	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
839	if err != nil {
840		t.Fatal(err)
841	}
842
843	resp, err := c.GetAlertPolicy(context.Background(), request)
844
845	if st, ok := gstatus.FromError(err); !ok {
846		t.Errorf("got error %v, expected grpc error", err)
847	} else if c := st.Code(); c != errCode {
848		t.Errorf("got error code %q, want %q", c, errCode)
849	}
850	_ = resp
851}
852func TestAlertPolicyServiceCreateAlertPolicy(t *testing.T) {
853	var name2 string = "name2-1052831874"
854	var displayName string = "displayName1615086568"
855	var expectedResponse = &monitoringpb.AlertPolicy{
856		Name:        name2,
857		DisplayName: displayName,
858	}
859
860	mockAlertPolicy.err = nil
861	mockAlertPolicy.reqs = nil
862
863	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
864
865	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
866	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
867	var request = &monitoringpb.CreateAlertPolicyRequest{
868		Name:        formattedName,
869		AlertPolicy: alertPolicy,
870	}
871
872	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
873	if err != nil {
874		t.Fatal(err)
875	}
876
877	resp, err := c.CreateAlertPolicy(context.Background(), request)
878
879	if err != nil {
880		t.Fatal(err)
881	}
882
883	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
884		t.Errorf("wrong request %q, want %q", got, want)
885	}
886
887	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
888		t.Errorf("wrong response %q, want %q)", got, want)
889	}
890}
891
892func TestAlertPolicyServiceCreateAlertPolicyError(t *testing.T) {
893	errCode := codes.PermissionDenied
894	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
895
896	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
897	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
898	var request = &monitoringpb.CreateAlertPolicyRequest{
899		Name:        formattedName,
900		AlertPolicy: alertPolicy,
901	}
902
903	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
904	if err != nil {
905		t.Fatal(err)
906	}
907
908	resp, err := c.CreateAlertPolicy(context.Background(), request)
909
910	if st, ok := gstatus.FromError(err); !ok {
911		t.Errorf("got error %v, expected grpc error", err)
912	} else if c := st.Code(); c != errCode {
913		t.Errorf("got error code %q, want %q", c, errCode)
914	}
915	_ = resp
916}
917func TestAlertPolicyServiceDeleteAlertPolicy(t *testing.T) {
918	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
919
920	mockAlertPolicy.err = nil
921	mockAlertPolicy.reqs = nil
922
923	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
924
925	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
926	var request = &monitoringpb.DeleteAlertPolicyRequest{
927		Name: formattedName,
928	}
929
930	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
931	if err != nil {
932		t.Fatal(err)
933	}
934
935	err = c.DeleteAlertPolicy(context.Background(), request)
936
937	if err != nil {
938		t.Fatal(err)
939	}
940
941	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
942		t.Errorf("wrong request %q, want %q", got, want)
943	}
944
945}
946
947func TestAlertPolicyServiceDeleteAlertPolicyError(t *testing.T) {
948	errCode := codes.PermissionDenied
949	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
950
951	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
952	var request = &monitoringpb.DeleteAlertPolicyRequest{
953		Name: formattedName,
954	}
955
956	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
957	if err != nil {
958		t.Fatal(err)
959	}
960
961	err = c.DeleteAlertPolicy(context.Background(), request)
962
963	if st, ok := gstatus.FromError(err); !ok {
964		t.Errorf("got error %v, expected grpc error", err)
965	} else if c := st.Code(); c != errCode {
966		t.Errorf("got error code %q, want %q", c, errCode)
967	}
968}
969func TestAlertPolicyServiceUpdateAlertPolicy(t *testing.T) {
970	var name string = "name3373707"
971	var displayName string = "displayName1615086568"
972	var expectedResponse = &monitoringpb.AlertPolicy{
973		Name:        name,
974		DisplayName: displayName,
975	}
976
977	mockAlertPolicy.err = nil
978	mockAlertPolicy.reqs = nil
979
980	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
981
982	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
983	var request = &monitoringpb.UpdateAlertPolicyRequest{
984		AlertPolicy: alertPolicy,
985	}
986
987	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
988	if err != nil {
989		t.Fatal(err)
990	}
991
992	resp, err := c.UpdateAlertPolicy(context.Background(), request)
993
994	if err != nil {
995		t.Fatal(err)
996	}
997
998	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
999		t.Errorf("wrong request %q, want %q", got, want)
1000	}
1001
1002	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1003		t.Errorf("wrong response %q, want %q)", got, want)
1004	}
1005}
1006
1007func TestAlertPolicyServiceUpdateAlertPolicyError(t *testing.T) {
1008	errCode := codes.PermissionDenied
1009	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
1010
1011	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
1012	var request = &monitoringpb.UpdateAlertPolicyRequest{
1013		AlertPolicy: alertPolicy,
1014	}
1015
1016	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
1017	if err != nil {
1018		t.Fatal(err)
1019	}
1020
1021	resp, err := c.UpdateAlertPolicy(context.Background(), request)
1022
1023	if st, ok := gstatus.FromError(err); !ok {
1024		t.Errorf("got error %v, expected grpc error", err)
1025	} else if c := st.Code(); c != errCode {
1026		t.Errorf("got error code %q, want %q", c, errCode)
1027	}
1028	_ = resp
1029}
1030func TestGroupServiceListGroups(t *testing.T) {
1031	var nextPageToken string = ""
1032	var groupElement *monitoringpb.Group = &monitoringpb.Group{}
1033	var group = []*monitoringpb.Group{groupElement}
1034	var expectedResponse = &monitoringpb.ListGroupsResponse{
1035		NextPageToken: nextPageToken,
1036		Group:         group,
1037	}
1038
1039	mockGroup.err = nil
1040	mockGroup.reqs = nil
1041
1042	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1043
1044	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1045	var request = &monitoringpb.ListGroupsRequest{
1046		Name: formattedName,
1047	}
1048
1049	c, err := NewGroupClient(context.Background(), clientOpt)
1050	if err != nil {
1051		t.Fatal(err)
1052	}
1053
1054	resp, err := c.ListGroups(context.Background(), request).Next()
1055
1056	if err != nil {
1057		t.Fatal(err)
1058	}
1059
1060	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1061		t.Errorf("wrong request %q, want %q", got, want)
1062	}
1063
1064	want := (interface{})(expectedResponse.Group[0])
1065	got := (interface{})(resp)
1066	var ok bool
1067
1068	switch want := (want).(type) {
1069	case proto.Message:
1070		ok = proto.Equal(want, got.(proto.Message))
1071	default:
1072		ok = want == got
1073	}
1074	if !ok {
1075		t.Errorf("wrong response %q, want %q)", got, want)
1076	}
1077}
1078
1079func TestGroupServiceListGroupsError(t *testing.T) {
1080	errCode := codes.PermissionDenied
1081	mockGroup.err = gstatus.Error(errCode, "test error")
1082
1083	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1084	var request = &monitoringpb.ListGroupsRequest{
1085		Name: formattedName,
1086	}
1087
1088	c, err := NewGroupClient(context.Background(), clientOpt)
1089	if err != nil {
1090		t.Fatal(err)
1091	}
1092
1093	resp, err := c.ListGroups(context.Background(), request).Next()
1094
1095	if st, ok := gstatus.FromError(err); !ok {
1096		t.Errorf("got error %v, expected grpc error", err)
1097	} else if c := st.Code(); c != errCode {
1098		t.Errorf("got error code %q, want %q", c, errCode)
1099	}
1100	_ = resp
1101}
1102func TestGroupServiceGetGroup(t *testing.T) {
1103	var name2 string = "name2-1052831874"
1104	var displayName string = "displayName1615086568"
1105	var parentName string = "parentName1015022848"
1106	var filter string = "filter-1274492040"
1107	var isCluster bool = false
1108	var expectedResponse = &monitoringpb.Group{
1109		Name:        name2,
1110		DisplayName: displayName,
1111		ParentName:  parentName,
1112		Filter:      filter,
1113		IsCluster:   isCluster,
1114	}
1115
1116	mockGroup.err = nil
1117	mockGroup.reqs = nil
1118
1119	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1120
1121	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1122	var request = &monitoringpb.GetGroupRequest{
1123		Name: formattedName,
1124	}
1125
1126	c, err := NewGroupClient(context.Background(), clientOpt)
1127	if err != nil {
1128		t.Fatal(err)
1129	}
1130
1131	resp, err := c.GetGroup(context.Background(), request)
1132
1133	if err != nil {
1134		t.Fatal(err)
1135	}
1136
1137	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1138		t.Errorf("wrong request %q, want %q", got, want)
1139	}
1140
1141	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1142		t.Errorf("wrong response %q, want %q)", got, want)
1143	}
1144}
1145
1146func TestGroupServiceGetGroupError(t *testing.T) {
1147	errCode := codes.PermissionDenied
1148	mockGroup.err = gstatus.Error(errCode, "test error")
1149
1150	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1151	var request = &monitoringpb.GetGroupRequest{
1152		Name: formattedName,
1153	}
1154
1155	c, err := NewGroupClient(context.Background(), clientOpt)
1156	if err != nil {
1157		t.Fatal(err)
1158	}
1159
1160	resp, err := c.GetGroup(context.Background(), request)
1161
1162	if st, ok := gstatus.FromError(err); !ok {
1163		t.Errorf("got error %v, expected grpc error", err)
1164	} else if c := st.Code(); c != errCode {
1165		t.Errorf("got error code %q, want %q", c, errCode)
1166	}
1167	_ = resp
1168}
1169func TestGroupServiceCreateGroup(t *testing.T) {
1170	var name2 string = "name2-1052831874"
1171	var displayName string = "displayName1615086568"
1172	var parentName string = "parentName1015022848"
1173	var filter string = "filter-1274492040"
1174	var isCluster bool = false
1175	var expectedResponse = &monitoringpb.Group{
1176		Name:        name2,
1177		DisplayName: displayName,
1178		ParentName:  parentName,
1179		Filter:      filter,
1180		IsCluster:   isCluster,
1181	}
1182
1183	mockGroup.err = nil
1184	mockGroup.reqs = nil
1185
1186	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1187
1188	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1189	var group *monitoringpb.Group = &monitoringpb.Group{}
1190	var request = &monitoringpb.CreateGroupRequest{
1191		Name:  formattedName,
1192		Group: group,
1193	}
1194
1195	c, err := NewGroupClient(context.Background(), clientOpt)
1196	if err != nil {
1197		t.Fatal(err)
1198	}
1199
1200	resp, err := c.CreateGroup(context.Background(), request)
1201
1202	if err != nil {
1203		t.Fatal(err)
1204	}
1205
1206	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1207		t.Errorf("wrong request %q, want %q", got, want)
1208	}
1209
1210	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1211		t.Errorf("wrong response %q, want %q)", got, want)
1212	}
1213}
1214
1215func TestGroupServiceCreateGroupError(t *testing.T) {
1216	errCode := codes.PermissionDenied
1217	mockGroup.err = gstatus.Error(errCode, "test error")
1218
1219	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1220	var group *monitoringpb.Group = &monitoringpb.Group{}
1221	var request = &monitoringpb.CreateGroupRequest{
1222		Name:  formattedName,
1223		Group: group,
1224	}
1225
1226	c, err := NewGroupClient(context.Background(), clientOpt)
1227	if err != nil {
1228		t.Fatal(err)
1229	}
1230
1231	resp, err := c.CreateGroup(context.Background(), request)
1232
1233	if st, ok := gstatus.FromError(err); !ok {
1234		t.Errorf("got error %v, expected grpc error", err)
1235	} else if c := st.Code(); c != errCode {
1236		t.Errorf("got error code %q, want %q", c, errCode)
1237	}
1238	_ = resp
1239}
1240func TestGroupServiceUpdateGroup(t *testing.T) {
1241	var name string = "name3373707"
1242	var displayName string = "displayName1615086568"
1243	var parentName string = "parentName1015022848"
1244	var filter string = "filter-1274492040"
1245	var isCluster bool = false
1246	var expectedResponse = &monitoringpb.Group{
1247		Name:        name,
1248		DisplayName: displayName,
1249		ParentName:  parentName,
1250		Filter:      filter,
1251		IsCluster:   isCluster,
1252	}
1253
1254	mockGroup.err = nil
1255	mockGroup.reqs = nil
1256
1257	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1258
1259	var group *monitoringpb.Group = &monitoringpb.Group{}
1260	var request = &monitoringpb.UpdateGroupRequest{
1261		Group: group,
1262	}
1263
1264	c, err := NewGroupClient(context.Background(), clientOpt)
1265	if err != nil {
1266		t.Fatal(err)
1267	}
1268
1269	resp, err := c.UpdateGroup(context.Background(), request)
1270
1271	if err != nil {
1272		t.Fatal(err)
1273	}
1274
1275	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1276		t.Errorf("wrong request %q, want %q", got, want)
1277	}
1278
1279	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1280		t.Errorf("wrong response %q, want %q)", got, want)
1281	}
1282}
1283
1284func TestGroupServiceUpdateGroupError(t *testing.T) {
1285	errCode := codes.PermissionDenied
1286	mockGroup.err = gstatus.Error(errCode, "test error")
1287
1288	var group *monitoringpb.Group = &monitoringpb.Group{}
1289	var request = &monitoringpb.UpdateGroupRequest{
1290		Group: group,
1291	}
1292
1293	c, err := NewGroupClient(context.Background(), clientOpt)
1294	if err != nil {
1295		t.Fatal(err)
1296	}
1297
1298	resp, err := c.UpdateGroup(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	_ = resp
1306}
1307func TestGroupServiceDeleteGroup(t *testing.T) {
1308	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1309
1310	mockGroup.err = nil
1311	mockGroup.reqs = nil
1312
1313	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1314
1315	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1316	var request = &monitoringpb.DeleteGroupRequest{
1317		Name: formattedName,
1318	}
1319
1320	c, err := NewGroupClient(context.Background(), clientOpt)
1321	if err != nil {
1322		t.Fatal(err)
1323	}
1324
1325	err = c.DeleteGroup(context.Background(), request)
1326
1327	if err != nil {
1328		t.Fatal(err)
1329	}
1330
1331	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1332		t.Errorf("wrong request %q, want %q", got, want)
1333	}
1334
1335}
1336
1337func TestGroupServiceDeleteGroupError(t *testing.T) {
1338	errCode := codes.PermissionDenied
1339	mockGroup.err = gstatus.Error(errCode, "test error")
1340
1341	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1342	var request = &monitoringpb.DeleteGroupRequest{
1343		Name: formattedName,
1344	}
1345
1346	c, err := NewGroupClient(context.Background(), clientOpt)
1347	if err != nil {
1348		t.Fatal(err)
1349	}
1350
1351	err = c.DeleteGroup(context.Background(), request)
1352
1353	if st, ok := gstatus.FromError(err); !ok {
1354		t.Errorf("got error %v, expected grpc error", err)
1355	} else if c := st.Code(); c != errCode {
1356		t.Errorf("got error code %q, want %q", c, errCode)
1357	}
1358}
1359func TestGroupServiceListGroupMembers(t *testing.T) {
1360	var nextPageToken string = ""
1361	var totalSize int32 = 705419236
1362	var membersElement *monitoredrespb.MonitoredResource = &monitoredrespb.MonitoredResource{}
1363	var members = []*monitoredrespb.MonitoredResource{membersElement}
1364	var expectedResponse = &monitoringpb.ListGroupMembersResponse{
1365		NextPageToken: nextPageToken,
1366		TotalSize:     totalSize,
1367		Members:       members,
1368	}
1369
1370	mockGroup.err = nil
1371	mockGroup.reqs = nil
1372
1373	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1374
1375	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1376	var request = &monitoringpb.ListGroupMembersRequest{
1377		Name: formattedName,
1378	}
1379
1380	c, err := NewGroupClient(context.Background(), clientOpt)
1381	if err != nil {
1382		t.Fatal(err)
1383	}
1384
1385	resp, err := c.ListGroupMembers(context.Background(), request).Next()
1386
1387	if err != nil {
1388		t.Fatal(err)
1389	}
1390
1391	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1392		t.Errorf("wrong request %q, want %q", got, want)
1393	}
1394
1395	want := (interface{})(expectedResponse.Members[0])
1396	got := (interface{})(resp)
1397	var ok bool
1398
1399	switch want := (want).(type) {
1400	case proto.Message:
1401		ok = proto.Equal(want, got.(proto.Message))
1402	default:
1403		ok = want == got
1404	}
1405	if !ok {
1406		t.Errorf("wrong response %q, want %q)", got, want)
1407	}
1408}
1409
1410func TestGroupServiceListGroupMembersError(t *testing.T) {
1411	errCode := codes.PermissionDenied
1412	mockGroup.err = gstatus.Error(errCode, "test error")
1413
1414	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1415	var request = &monitoringpb.ListGroupMembersRequest{
1416		Name: formattedName,
1417	}
1418
1419	c, err := NewGroupClient(context.Background(), clientOpt)
1420	if err != nil {
1421		t.Fatal(err)
1422	}
1423
1424	resp, err := c.ListGroupMembers(context.Background(), request).Next()
1425
1426	if st, ok := gstatus.FromError(err); !ok {
1427		t.Errorf("got error %v, expected grpc error", err)
1428	} else if c := st.Code(); c != errCode {
1429		t.Errorf("got error code %q, want %q", c, errCode)
1430	}
1431	_ = resp
1432}
1433func TestMetricServiceListMonitoredResourceDescriptors(t *testing.T) {
1434	var nextPageToken string = ""
1435	var resourceDescriptorsElement *monitoredrespb.MonitoredResourceDescriptor = &monitoredrespb.MonitoredResourceDescriptor{}
1436	var resourceDescriptors = []*monitoredrespb.MonitoredResourceDescriptor{resourceDescriptorsElement}
1437	var expectedResponse = &monitoringpb.ListMonitoredResourceDescriptorsResponse{
1438		NextPageToken:       nextPageToken,
1439		ResourceDescriptors: resourceDescriptors,
1440	}
1441
1442	mockMetric.err = nil
1443	mockMetric.reqs = nil
1444
1445	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1446
1447	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1448	var request = &monitoringpb.ListMonitoredResourceDescriptorsRequest{
1449		Name: formattedName,
1450	}
1451
1452	c, err := NewMetricClient(context.Background(), clientOpt)
1453	if err != nil {
1454		t.Fatal(err)
1455	}
1456
1457	resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next()
1458
1459	if err != nil {
1460		t.Fatal(err)
1461	}
1462
1463	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1464		t.Errorf("wrong request %q, want %q", got, want)
1465	}
1466
1467	want := (interface{})(expectedResponse.ResourceDescriptors[0])
1468	got := (interface{})(resp)
1469	var ok bool
1470
1471	switch want := (want).(type) {
1472	case proto.Message:
1473		ok = proto.Equal(want, got.(proto.Message))
1474	default:
1475		ok = want == got
1476	}
1477	if !ok {
1478		t.Errorf("wrong response %q, want %q)", got, want)
1479	}
1480}
1481
1482func TestMetricServiceListMonitoredResourceDescriptorsError(t *testing.T) {
1483	errCode := codes.PermissionDenied
1484	mockMetric.err = gstatus.Error(errCode, "test error")
1485
1486	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1487	var request = &monitoringpb.ListMonitoredResourceDescriptorsRequest{
1488		Name: formattedName,
1489	}
1490
1491	c, err := NewMetricClient(context.Background(), clientOpt)
1492	if err != nil {
1493		t.Fatal(err)
1494	}
1495
1496	resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next()
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	_ = resp
1504}
1505func TestMetricServiceGetMonitoredResourceDescriptor(t *testing.T) {
1506	var name2 string = "name2-1052831874"
1507	var type_ string = "type3575610"
1508	var displayName string = "displayName1615086568"
1509	var description string = "description-1724546052"
1510	var expectedResponse = &monitoredrespb.MonitoredResourceDescriptor{
1511		Name:        name2,
1512		Type:        type_,
1513		DisplayName: displayName,
1514		Description: description,
1515	}
1516
1517	mockMetric.err = nil
1518	mockMetric.reqs = nil
1519
1520	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1521
1522	var formattedName string = fmt.Sprintf("projects/%s/monitoredResourceDescriptors/%s", "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]")
1523	var request = &monitoringpb.GetMonitoredResourceDescriptorRequest{
1524		Name: formattedName,
1525	}
1526
1527	c, err := NewMetricClient(context.Background(), clientOpt)
1528	if err != nil {
1529		t.Fatal(err)
1530	}
1531
1532	resp, err := c.GetMonitoredResourceDescriptor(context.Background(), request)
1533
1534	if err != nil {
1535		t.Fatal(err)
1536	}
1537
1538	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1539		t.Errorf("wrong request %q, want %q", got, want)
1540	}
1541
1542	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1543		t.Errorf("wrong response %q, want %q)", got, want)
1544	}
1545}
1546
1547func TestMetricServiceGetMonitoredResourceDescriptorError(t *testing.T) {
1548	errCode := codes.PermissionDenied
1549	mockMetric.err = gstatus.Error(errCode, "test error")
1550
1551	var formattedName string = fmt.Sprintf("projects/%s/monitoredResourceDescriptors/%s", "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]")
1552	var request = &monitoringpb.GetMonitoredResourceDescriptorRequest{
1553		Name: formattedName,
1554	}
1555
1556	c, err := NewMetricClient(context.Background(), clientOpt)
1557	if err != nil {
1558		t.Fatal(err)
1559	}
1560
1561	resp, err := c.GetMonitoredResourceDescriptor(context.Background(), request)
1562
1563	if st, ok := gstatus.FromError(err); !ok {
1564		t.Errorf("got error %v, expected grpc error", err)
1565	} else if c := st.Code(); c != errCode {
1566		t.Errorf("got error code %q, want %q", c, errCode)
1567	}
1568	_ = resp
1569}
1570func TestMetricServiceListMetricDescriptors(t *testing.T) {
1571	var nextPageToken string = ""
1572	var metricDescriptorsElement *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1573	var metricDescriptors = []*metricpb.MetricDescriptor{metricDescriptorsElement}
1574	var expectedResponse = &monitoringpb.ListMetricDescriptorsResponse{
1575		NextPageToken:     nextPageToken,
1576		MetricDescriptors: metricDescriptors,
1577	}
1578
1579	mockMetric.err = nil
1580	mockMetric.reqs = nil
1581
1582	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1583
1584	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1585	var request = &monitoringpb.ListMetricDescriptorsRequest{
1586		Name: formattedName,
1587	}
1588
1589	c, err := NewMetricClient(context.Background(), clientOpt)
1590	if err != nil {
1591		t.Fatal(err)
1592	}
1593
1594	resp, err := c.ListMetricDescriptors(context.Background(), request).Next()
1595
1596	if err != nil {
1597		t.Fatal(err)
1598	}
1599
1600	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1601		t.Errorf("wrong request %q, want %q", got, want)
1602	}
1603
1604	want := (interface{})(expectedResponse.MetricDescriptors[0])
1605	got := (interface{})(resp)
1606	var ok bool
1607
1608	switch want := (want).(type) {
1609	case proto.Message:
1610		ok = proto.Equal(want, got.(proto.Message))
1611	default:
1612		ok = want == got
1613	}
1614	if !ok {
1615		t.Errorf("wrong response %q, want %q)", got, want)
1616	}
1617}
1618
1619func TestMetricServiceListMetricDescriptorsError(t *testing.T) {
1620	errCode := codes.PermissionDenied
1621	mockMetric.err = gstatus.Error(errCode, "test error")
1622
1623	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1624	var request = &monitoringpb.ListMetricDescriptorsRequest{
1625		Name: formattedName,
1626	}
1627
1628	c, err := NewMetricClient(context.Background(), clientOpt)
1629	if err != nil {
1630		t.Fatal(err)
1631	}
1632
1633	resp, err := c.ListMetricDescriptors(context.Background(), request).Next()
1634
1635	if st, ok := gstatus.FromError(err); !ok {
1636		t.Errorf("got error %v, expected grpc error", err)
1637	} else if c := st.Code(); c != errCode {
1638		t.Errorf("got error code %q, want %q", c, errCode)
1639	}
1640	_ = resp
1641}
1642func TestMetricServiceGetMetricDescriptor(t *testing.T) {
1643	var name2 string = "name2-1052831874"
1644	var type_ string = "type3575610"
1645	var unit string = "unit3594628"
1646	var description string = "description-1724546052"
1647	var displayName string = "displayName1615086568"
1648	var expectedResponse = &metricpb.MetricDescriptor{
1649		Name:        name2,
1650		Type:        type_,
1651		Unit:        unit,
1652		Description: description,
1653		DisplayName: displayName,
1654	}
1655
1656	mockMetric.err = nil
1657	mockMetric.reqs = nil
1658
1659	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1660
1661	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1662	var request = &monitoringpb.GetMetricDescriptorRequest{
1663		Name: formattedName,
1664	}
1665
1666	c, err := NewMetricClient(context.Background(), clientOpt)
1667	if err != nil {
1668		t.Fatal(err)
1669	}
1670
1671	resp, err := c.GetMetricDescriptor(context.Background(), request)
1672
1673	if err != nil {
1674		t.Fatal(err)
1675	}
1676
1677	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1678		t.Errorf("wrong request %q, want %q", got, want)
1679	}
1680
1681	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1682		t.Errorf("wrong response %q, want %q)", got, want)
1683	}
1684}
1685
1686func TestMetricServiceGetMetricDescriptorError(t *testing.T) {
1687	errCode := codes.PermissionDenied
1688	mockMetric.err = gstatus.Error(errCode, "test error")
1689
1690	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1691	var request = &monitoringpb.GetMetricDescriptorRequest{
1692		Name: formattedName,
1693	}
1694
1695	c, err := NewMetricClient(context.Background(), clientOpt)
1696	if err != nil {
1697		t.Fatal(err)
1698	}
1699
1700	resp, err := c.GetMetricDescriptor(context.Background(), request)
1701
1702	if st, ok := gstatus.FromError(err); !ok {
1703		t.Errorf("got error %v, expected grpc error", err)
1704	} else if c := st.Code(); c != errCode {
1705		t.Errorf("got error code %q, want %q", c, errCode)
1706	}
1707	_ = resp
1708}
1709func TestMetricServiceCreateMetricDescriptor(t *testing.T) {
1710	var name2 string = "name2-1052831874"
1711	var type_ string = "type3575610"
1712	var unit string = "unit3594628"
1713	var description string = "description-1724546052"
1714	var displayName string = "displayName1615086568"
1715	var expectedResponse = &metricpb.MetricDescriptor{
1716		Name:        name2,
1717		Type:        type_,
1718		Unit:        unit,
1719		Description: description,
1720		DisplayName: displayName,
1721	}
1722
1723	mockMetric.err = nil
1724	mockMetric.reqs = nil
1725
1726	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1727
1728	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1729	var metricDescriptor *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1730	var request = &monitoringpb.CreateMetricDescriptorRequest{
1731		Name:             formattedName,
1732		MetricDescriptor: metricDescriptor,
1733	}
1734
1735	c, err := NewMetricClient(context.Background(), clientOpt)
1736	if err != nil {
1737		t.Fatal(err)
1738	}
1739
1740	resp, err := c.CreateMetricDescriptor(context.Background(), request)
1741
1742	if err != nil {
1743		t.Fatal(err)
1744	}
1745
1746	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1747		t.Errorf("wrong request %q, want %q", got, want)
1748	}
1749
1750	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1751		t.Errorf("wrong response %q, want %q)", got, want)
1752	}
1753}
1754
1755func TestMetricServiceCreateMetricDescriptorError(t *testing.T) {
1756	errCode := codes.PermissionDenied
1757	mockMetric.err = gstatus.Error(errCode, "test error")
1758
1759	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1760	var metricDescriptor *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1761	var request = &monitoringpb.CreateMetricDescriptorRequest{
1762		Name:             formattedName,
1763		MetricDescriptor: metricDescriptor,
1764	}
1765
1766	c, err := NewMetricClient(context.Background(), clientOpt)
1767	if err != nil {
1768		t.Fatal(err)
1769	}
1770
1771	resp, err := c.CreateMetricDescriptor(context.Background(), request)
1772
1773	if st, ok := gstatus.FromError(err); !ok {
1774		t.Errorf("got error %v, expected grpc error", err)
1775	} else if c := st.Code(); c != errCode {
1776		t.Errorf("got error code %q, want %q", c, errCode)
1777	}
1778	_ = resp
1779}
1780func TestMetricServiceDeleteMetricDescriptor(t *testing.T) {
1781	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1782
1783	mockMetric.err = nil
1784	mockMetric.reqs = nil
1785
1786	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1787
1788	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1789	var request = &monitoringpb.DeleteMetricDescriptorRequest{
1790		Name: formattedName,
1791	}
1792
1793	c, err := NewMetricClient(context.Background(), clientOpt)
1794	if err != nil {
1795		t.Fatal(err)
1796	}
1797
1798	err = c.DeleteMetricDescriptor(context.Background(), request)
1799
1800	if err != nil {
1801		t.Fatal(err)
1802	}
1803
1804	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1805		t.Errorf("wrong request %q, want %q", got, want)
1806	}
1807
1808}
1809
1810func TestMetricServiceDeleteMetricDescriptorError(t *testing.T) {
1811	errCode := codes.PermissionDenied
1812	mockMetric.err = gstatus.Error(errCode, "test error")
1813
1814	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1815	var request = &monitoringpb.DeleteMetricDescriptorRequest{
1816		Name: formattedName,
1817	}
1818
1819	c, err := NewMetricClient(context.Background(), clientOpt)
1820	if err != nil {
1821		t.Fatal(err)
1822	}
1823
1824	err = c.DeleteMetricDescriptor(context.Background(), request)
1825
1826	if st, ok := gstatus.FromError(err); !ok {
1827		t.Errorf("got error %v, expected grpc error", err)
1828	} else if c := st.Code(); c != errCode {
1829		t.Errorf("got error code %q, want %q", c, errCode)
1830	}
1831}
1832func TestMetricServiceListTimeSeries(t *testing.T) {
1833	var nextPageToken string = ""
1834	var timeSeriesElement *monitoringpb.TimeSeries = &monitoringpb.TimeSeries{}
1835	var timeSeries = []*monitoringpb.TimeSeries{timeSeriesElement}
1836	var expectedResponse = &monitoringpb.ListTimeSeriesResponse{
1837		NextPageToken: nextPageToken,
1838		TimeSeries:    timeSeries,
1839	}
1840
1841	mockMetric.err = nil
1842	mockMetric.reqs = nil
1843
1844	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1845
1846	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1847	var filter string = "filter-1274492040"
1848	var interval *monitoringpb.TimeInterval = &monitoringpb.TimeInterval{}
1849	var view monitoringpb.ListTimeSeriesRequest_TimeSeriesView = monitoringpb.ListTimeSeriesRequest_FULL
1850	var request = &monitoringpb.ListTimeSeriesRequest{
1851		Name:     formattedName,
1852		Filter:   filter,
1853		Interval: interval,
1854		View:     view,
1855	}
1856
1857	c, err := NewMetricClient(context.Background(), clientOpt)
1858	if err != nil {
1859		t.Fatal(err)
1860	}
1861
1862	resp, err := c.ListTimeSeries(context.Background(), request).Next()
1863
1864	if err != nil {
1865		t.Fatal(err)
1866	}
1867
1868	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1869		t.Errorf("wrong request %q, want %q", got, want)
1870	}
1871
1872	want := (interface{})(expectedResponse.TimeSeries[0])
1873	got := (interface{})(resp)
1874	var ok bool
1875
1876	switch want := (want).(type) {
1877	case proto.Message:
1878		ok = proto.Equal(want, got.(proto.Message))
1879	default:
1880		ok = want == got
1881	}
1882	if !ok {
1883		t.Errorf("wrong response %q, want %q)", got, want)
1884	}
1885}
1886
1887func TestMetricServiceListTimeSeriesError(t *testing.T) {
1888	errCode := codes.PermissionDenied
1889	mockMetric.err = gstatus.Error(errCode, "test error")
1890
1891	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1892	var filter string = "filter-1274492040"
1893	var interval *monitoringpb.TimeInterval = &monitoringpb.TimeInterval{}
1894	var view monitoringpb.ListTimeSeriesRequest_TimeSeriesView = monitoringpb.ListTimeSeriesRequest_FULL
1895	var request = &monitoringpb.ListTimeSeriesRequest{
1896		Name:     formattedName,
1897		Filter:   filter,
1898		Interval: interval,
1899		View:     view,
1900	}
1901
1902	c, err := NewMetricClient(context.Background(), clientOpt)
1903	if err != nil {
1904		t.Fatal(err)
1905	}
1906
1907	resp, err := c.ListTimeSeries(context.Background(), request).Next()
1908
1909	if st, ok := gstatus.FromError(err); !ok {
1910		t.Errorf("got error %v, expected grpc error", err)
1911	} else if c := st.Code(); c != errCode {
1912		t.Errorf("got error code %q, want %q", c, errCode)
1913	}
1914	_ = resp
1915}
1916func TestMetricServiceCreateTimeSeries(t *testing.T) {
1917	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1918
1919	mockMetric.err = nil
1920	mockMetric.reqs = nil
1921
1922	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1923
1924	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1925	var timeSeries []*monitoringpb.TimeSeries = nil
1926	var request = &monitoringpb.CreateTimeSeriesRequest{
1927		Name:       formattedName,
1928		TimeSeries: timeSeries,
1929	}
1930
1931	c, err := NewMetricClient(context.Background(), clientOpt)
1932	if err != nil {
1933		t.Fatal(err)
1934	}
1935
1936	err = c.CreateTimeSeries(context.Background(), request)
1937
1938	if err != nil {
1939		t.Fatal(err)
1940	}
1941
1942	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1943		t.Errorf("wrong request %q, want %q", got, want)
1944	}
1945
1946}
1947
1948func TestMetricServiceCreateTimeSeriesError(t *testing.T) {
1949	errCode := codes.PermissionDenied
1950	mockMetric.err = gstatus.Error(errCode, "test error")
1951
1952	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1953	var timeSeries []*monitoringpb.TimeSeries = nil
1954	var request = &monitoringpb.CreateTimeSeriesRequest{
1955		Name:       formattedName,
1956		TimeSeries: timeSeries,
1957	}
1958
1959	c, err := NewMetricClient(context.Background(), clientOpt)
1960	if err != nil {
1961		t.Fatal(err)
1962	}
1963
1964	err = c.CreateTimeSeries(context.Background(), request)
1965
1966	if st, ok := gstatus.FromError(err); !ok {
1967		t.Errorf("got error %v, expected grpc error", err)
1968	} else if c := st.Code(); c != errCode {
1969		t.Errorf("got error code %q, want %q", c, errCode)
1970	}
1971}
1972func TestNotificationChannelServiceListNotificationChannelDescriptors(t *testing.T) {
1973	var nextPageToken string = ""
1974	var channelDescriptorsElement *monitoringpb.NotificationChannelDescriptor = &monitoringpb.NotificationChannelDescriptor{}
1975	var channelDescriptors = []*monitoringpb.NotificationChannelDescriptor{channelDescriptorsElement}
1976	var expectedResponse = &monitoringpb.ListNotificationChannelDescriptorsResponse{
1977		NextPageToken:      nextPageToken,
1978		ChannelDescriptors: channelDescriptors,
1979	}
1980
1981	mockNotificationChannel.err = nil
1982	mockNotificationChannel.reqs = nil
1983
1984	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
1985
1986	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1987	var request = &monitoringpb.ListNotificationChannelDescriptorsRequest{
1988		Name: formattedName,
1989	}
1990
1991	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1992	if err != nil {
1993		t.Fatal(err)
1994	}
1995
1996	resp, err := c.ListNotificationChannelDescriptors(context.Background(), request).Next()
1997
1998	if err != nil {
1999		t.Fatal(err)
2000	}
2001
2002	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2003		t.Errorf("wrong request %q, want %q", got, want)
2004	}
2005
2006	want := (interface{})(expectedResponse.ChannelDescriptors[0])
2007	got := (interface{})(resp)
2008	var ok bool
2009
2010	switch want := (want).(type) {
2011	case proto.Message:
2012		ok = proto.Equal(want, got.(proto.Message))
2013	default:
2014		ok = want == got
2015	}
2016	if !ok {
2017		t.Errorf("wrong response %q, want %q)", got, want)
2018	}
2019}
2020
2021func TestNotificationChannelServiceListNotificationChannelDescriptorsError(t *testing.T) {
2022	errCode := codes.PermissionDenied
2023	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2024
2025	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2026	var request = &monitoringpb.ListNotificationChannelDescriptorsRequest{
2027		Name: formattedName,
2028	}
2029
2030	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2031	if err != nil {
2032		t.Fatal(err)
2033	}
2034
2035	resp, err := c.ListNotificationChannelDescriptors(context.Background(), request).Next()
2036
2037	if st, ok := gstatus.FromError(err); !ok {
2038		t.Errorf("got error %v, expected grpc error", err)
2039	} else if c := st.Code(); c != errCode {
2040		t.Errorf("got error code %q, want %q", c, errCode)
2041	}
2042	_ = resp
2043}
2044func TestNotificationChannelServiceGetNotificationChannelDescriptor(t *testing.T) {
2045	var name2 string = "name2-1052831874"
2046	var type_ string = "type3575610"
2047	var displayName string = "displayName1615086568"
2048	var description string = "description-1724546052"
2049	var expectedResponse = &monitoringpb.NotificationChannelDescriptor{
2050		Name:        name2,
2051		Type:        type_,
2052		DisplayName: displayName,
2053		Description: description,
2054	}
2055
2056	mockNotificationChannel.err = nil
2057	mockNotificationChannel.reqs = nil
2058
2059	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2060
2061	var formattedName string = fmt.Sprintf("projects/%s/notificationChannelDescriptors/%s", "[PROJECT]", "[CHANNEL_DESCRIPTOR]")
2062	var request = &monitoringpb.GetNotificationChannelDescriptorRequest{
2063		Name: formattedName,
2064	}
2065
2066	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2067	if err != nil {
2068		t.Fatal(err)
2069	}
2070
2071	resp, err := c.GetNotificationChannelDescriptor(context.Background(), request)
2072
2073	if err != nil {
2074		t.Fatal(err)
2075	}
2076
2077	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2078		t.Errorf("wrong request %q, want %q", got, want)
2079	}
2080
2081	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2082		t.Errorf("wrong response %q, want %q)", got, want)
2083	}
2084}
2085
2086func TestNotificationChannelServiceGetNotificationChannelDescriptorError(t *testing.T) {
2087	errCode := codes.PermissionDenied
2088	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2089
2090	var formattedName string = fmt.Sprintf("projects/%s/notificationChannelDescriptors/%s", "[PROJECT]", "[CHANNEL_DESCRIPTOR]")
2091	var request = &monitoringpb.GetNotificationChannelDescriptorRequest{
2092		Name: formattedName,
2093	}
2094
2095	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2096	if err != nil {
2097		t.Fatal(err)
2098	}
2099
2100	resp, err := c.GetNotificationChannelDescriptor(context.Background(), request)
2101
2102	if st, ok := gstatus.FromError(err); !ok {
2103		t.Errorf("got error %v, expected grpc error", err)
2104	} else if c := st.Code(); c != errCode {
2105		t.Errorf("got error code %q, want %q", c, errCode)
2106	}
2107	_ = resp
2108}
2109func TestNotificationChannelServiceListNotificationChannels(t *testing.T) {
2110	var nextPageToken string = ""
2111	var notificationChannelsElement *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2112	var notificationChannels = []*monitoringpb.NotificationChannel{notificationChannelsElement}
2113	var expectedResponse = &monitoringpb.ListNotificationChannelsResponse{
2114		NextPageToken:        nextPageToken,
2115		NotificationChannels: notificationChannels,
2116	}
2117
2118	mockNotificationChannel.err = nil
2119	mockNotificationChannel.reqs = nil
2120
2121	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2122
2123	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2124	var request = &monitoringpb.ListNotificationChannelsRequest{
2125		Name: formattedName,
2126	}
2127
2128	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2129	if err != nil {
2130		t.Fatal(err)
2131	}
2132
2133	resp, err := c.ListNotificationChannels(context.Background(), request).Next()
2134
2135	if err != nil {
2136		t.Fatal(err)
2137	}
2138
2139	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2140		t.Errorf("wrong request %q, want %q", got, want)
2141	}
2142
2143	want := (interface{})(expectedResponse.NotificationChannels[0])
2144	got := (interface{})(resp)
2145	var ok bool
2146
2147	switch want := (want).(type) {
2148	case proto.Message:
2149		ok = proto.Equal(want, got.(proto.Message))
2150	default:
2151		ok = want == got
2152	}
2153	if !ok {
2154		t.Errorf("wrong response %q, want %q)", got, want)
2155	}
2156}
2157
2158func TestNotificationChannelServiceListNotificationChannelsError(t *testing.T) {
2159	errCode := codes.PermissionDenied
2160	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2161
2162	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2163	var request = &monitoringpb.ListNotificationChannelsRequest{
2164		Name: formattedName,
2165	}
2166
2167	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2168	if err != nil {
2169		t.Fatal(err)
2170	}
2171
2172	resp, err := c.ListNotificationChannels(context.Background(), request).Next()
2173
2174	if st, ok := gstatus.FromError(err); !ok {
2175		t.Errorf("got error %v, expected grpc error", err)
2176	} else if c := st.Code(); c != errCode {
2177		t.Errorf("got error code %q, want %q", c, errCode)
2178	}
2179	_ = resp
2180}
2181func TestNotificationChannelServiceGetNotificationChannel(t *testing.T) {
2182	var type_ string = "type3575610"
2183	var name2 string = "name2-1052831874"
2184	var displayName string = "displayName1615086568"
2185	var description string = "description-1724546052"
2186	var expectedResponse = &monitoringpb.NotificationChannel{
2187		Type:        type_,
2188		Name:        name2,
2189		DisplayName: displayName,
2190		Description: description,
2191	}
2192
2193	mockNotificationChannel.err = nil
2194	mockNotificationChannel.reqs = nil
2195
2196	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2197
2198	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2199	var request = &monitoringpb.GetNotificationChannelRequest{
2200		Name: formattedName,
2201	}
2202
2203	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2204	if err != nil {
2205		t.Fatal(err)
2206	}
2207
2208	resp, err := c.GetNotificationChannel(context.Background(), request)
2209
2210	if err != nil {
2211		t.Fatal(err)
2212	}
2213
2214	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2215		t.Errorf("wrong request %q, want %q", got, want)
2216	}
2217
2218	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2219		t.Errorf("wrong response %q, want %q)", got, want)
2220	}
2221}
2222
2223func TestNotificationChannelServiceGetNotificationChannelError(t *testing.T) {
2224	errCode := codes.PermissionDenied
2225	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2226
2227	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2228	var request = &monitoringpb.GetNotificationChannelRequest{
2229		Name: formattedName,
2230	}
2231
2232	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2233	if err != nil {
2234		t.Fatal(err)
2235	}
2236
2237	resp, err := c.GetNotificationChannel(context.Background(), request)
2238
2239	if st, ok := gstatus.FromError(err); !ok {
2240		t.Errorf("got error %v, expected grpc error", err)
2241	} else if c := st.Code(); c != errCode {
2242		t.Errorf("got error code %q, want %q", c, errCode)
2243	}
2244	_ = resp
2245}
2246func TestNotificationChannelServiceCreateNotificationChannel(t *testing.T) {
2247	var type_ string = "type3575610"
2248	var name2 string = "name2-1052831874"
2249	var displayName string = "displayName1615086568"
2250	var description string = "description-1724546052"
2251	var expectedResponse = &monitoringpb.NotificationChannel{
2252		Type:        type_,
2253		Name:        name2,
2254		DisplayName: displayName,
2255		Description: description,
2256	}
2257
2258	mockNotificationChannel.err = nil
2259	mockNotificationChannel.reqs = nil
2260
2261	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2262
2263	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2264	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2265	var request = &monitoringpb.CreateNotificationChannelRequest{
2266		Name:                formattedName,
2267		NotificationChannel: notificationChannel,
2268	}
2269
2270	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2271	if err != nil {
2272		t.Fatal(err)
2273	}
2274
2275	resp, err := c.CreateNotificationChannel(context.Background(), request)
2276
2277	if err != nil {
2278		t.Fatal(err)
2279	}
2280
2281	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2282		t.Errorf("wrong request %q, want %q", got, want)
2283	}
2284
2285	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2286		t.Errorf("wrong response %q, want %q)", got, want)
2287	}
2288}
2289
2290func TestNotificationChannelServiceCreateNotificationChannelError(t *testing.T) {
2291	errCode := codes.PermissionDenied
2292	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2293
2294	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2295	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2296	var request = &monitoringpb.CreateNotificationChannelRequest{
2297		Name:                formattedName,
2298		NotificationChannel: notificationChannel,
2299	}
2300
2301	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2302	if err != nil {
2303		t.Fatal(err)
2304	}
2305
2306	resp, err := c.CreateNotificationChannel(context.Background(), request)
2307
2308	if st, ok := gstatus.FromError(err); !ok {
2309		t.Errorf("got error %v, expected grpc error", err)
2310	} else if c := st.Code(); c != errCode {
2311		t.Errorf("got error code %q, want %q", c, errCode)
2312	}
2313	_ = resp
2314}
2315func TestNotificationChannelServiceUpdateNotificationChannel(t *testing.T) {
2316	var type_ string = "type3575610"
2317	var name string = "name3373707"
2318	var displayName string = "displayName1615086568"
2319	var description string = "description-1724546052"
2320	var expectedResponse = &monitoringpb.NotificationChannel{
2321		Type:        type_,
2322		Name:        name,
2323		DisplayName: displayName,
2324		Description: description,
2325	}
2326
2327	mockNotificationChannel.err = nil
2328	mockNotificationChannel.reqs = nil
2329
2330	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2331
2332	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2333	var request = &monitoringpb.UpdateNotificationChannelRequest{
2334		NotificationChannel: notificationChannel,
2335	}
2336
2337	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2338	if err != nil {
2339		t.Fatal(err)
2340	}
2341
2342	resp, err := c.UpdateNotificationChannel(context.Background(), request)
2343
2344	if err != nil {
2345		t.Fatal(err)
2346	}
2347
2348	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2349		t.Errorf("wrong request %q, want %q", got, want)
2350	}
2351
2352	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2353		t.Errorf("wrong response %q, want %q)", got, want)
2354	}
2355}
2356
2357func TestNotificationChannelServiceUpdateNotificationChannelError(t *testing.T) {
2358	errCode := codes.PermissionDenied
2359	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2360
2361	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2362	var request = &monitoringpb.UpdateNotificationChannelRequest{
2363		NotificationChannel: notificationChannel,
2364	}
2365
2366	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2367	if err != nil {
2368		t.Fatal(err)
2369	}
2370
2371	resp, err := c.UpdateNotificationChannel(context.Background(), request)
2372
2373	if st, ok := gstatus.FromError(err); !ok {
2374		t.Errorf("got error %v, expected grpc error", err)
2375	} else if c := st.Code(); c != errCode {
2376		t.Errorf("got error code %q, want %q", c, errCode)
2377	}
2378	_ = resp
2379}
2380func TestNotificationChannelServiceDeleteNotificationChannel(t *testing.T) {
2381	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
2382
2383	mockNotificationChannel.err = nil
2384	mockNotificationChannel.reqs = nil
2385
2386	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2387
2388	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2389	var request = &monitoringpb.DeleteNotificationChannelRequest{
2390		Name: formattedName,
2391	}
2392
2393	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2394	if err != nil {
2395		t.Fatal(err)
2396	}
2397
2398	err = c.DeleteNotificationChannel(context.Background(), request)
2399
2400	if err != nil {
2401		t.Fatal(err)
2402	}
2403
2404	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2405		t.Errorf("wrong request %q, want %q", got, want)
2406	}
2407
2408}
2409
2410func TestNotificationChannelServiceDeleteNotificationChannelError(t *testing.T) {
2411	errCode := codes.PermissionDenied
2412	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2413
2414	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2415	var request = &monitoringpb.DeleteNotificationChannelRequest{
2416		Name: formattedName,
2417	}
2418
2419	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2420	if err != nil {
2421		t.Fatal(err)
2422	}
2423
2424	err = c.DeleteNotificationChannel(context.Background(), request)
2425
2426	if st, ok := gstatus.FromError(err); !ok {
2427		t.Errorf("got error %v, expected grpc error", err)
2428	} else if c := st.Code(); c != errCode {
2429		t.Errorf("got error code %q, want %q", c, errCode)
2430	}
2431}
2432func TestNotificationChannelServiceSendNotificationChannelVerificationCode(t *testing.T) {
2433	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
2434
2435	mockNotificationChannel.err = nil
2436	mockNotificationChannel.reqs = nil
2437
2438	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2439
2440	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2441	var request = &monitoringpb.SendNotificationChannelVerificationCodeRequest{
2442		Name: formattedName,
2443	}
2444
2445	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2446	if err != nil {
2447		t.Fatal(err)
2448	}
2449
2450	err = c.SendNotificationChannelVerificationCode(context.Background(), request)
2451
2452	if err != nil {
2453		t.Fatal(err)
2454	}
2455
2456	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2457		t.Errorf("wrong request %q, want %q", got, want)
2458	}
2459
2460}
2461
2462func TestNotificationChannelServiceSendNotificationChannelVerificationCodeError(t *testing.T) {
2463	errCode := codes.PermissionDenied
2464	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2465
2466	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2467	var request = &monitoringpb.SendNotificationChannelVerificationCodeRequest{
2468		Name: formattedName,
2469	}
2470
2471	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2472	if err != nil {
2473		t.Fatal(err)
2474	}
2475
2476	err = c.SendNotificationChannelVerificationCode(context.Background(), request)
2477
2478	if st, ok := gstatus.FromError(err); !ok {
2479		t.Errorf("got error %v, expected grpc error", err)
2480	} else if c := st.Code(); c != errCode {
2481		t.Errorf("got error code %q, want %q", c, errCode)
2482	}
2483}
2484func TestNotificationChannelServiceGetNotificationChannelVerificationCode(t *testing.T) {
2485	var code string = "code3059181"
2486	var expectedResponse = &monitoringpb.GetNotificationChannelVerificationCodeResponse{
2487		Code: code,
2488	}
2489
2490	mockNotificationChannel.err = nil
2491	mockNotificationChannel.reqs = nil
2492
2493	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2494
2495	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2496	var request = &monitoringpb.GetNotificationChannelVerificationCodeRequest{
2497		Name: formattedName,
2498	}
2499
2500	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2501	if err != nil {
2502		t.Fatal(err)
2503	}
2504
2505	resp, err := c.GetNotificationChannelVerificationCode(context.Background(), request)
2506
2507	if err != nil {
2508		t.Fatal(err)
2509	}
2510
2511	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2512		t.Errorf("wrong request %q, want %q", got, want)
2513	}
2514
2515	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2516		t.Errorf("wrong response %q, want %q)", got, want)
2517	}
2518}
2519
2520func TestNotificationChannelServiceGetNotificationChannelVerificationCodeError(t *testing.T) {
2521	errCode := codes.PermissionDenied
2522	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2523
2524	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2525	var request = &monitoringpb.GetNotificationChannelVerificationCodeRequest{
2526		Name: formattedName,
2527	}
2528
2529	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2530	if err != nil {
2531		t.Fatal(err)
2532	}
2533
2534	resp, err := c.GetNotificationChannelVerificationCode(context.Background(), request)
2535
2536	if st, ok := gstatus.FromError(err); !ok {
2537		t.Errorf("got error %v, expected grpc error", err)
2538	} else if c := st.Code(); c != errCode {
2539		t.Errorf("got error code %q, want %q", c, errCode)
2540	}
2541	_ = resp
2542}
2543func TestNotificationChannelServiceVerifyNotificationChannel(t *testing.T) {
2544	var type_ string = "type3575610"
2545	var name2 string = "name2-1052831874"
2546	var displayName string = "displayName1615086568"
2547	var description string = "description-1724546052"
2548	var expectedResponse = &monitoringpb.NotificationChannel{
2549		Type:        type_,
2550		Name:        name2,
2551		DisplayName: displayName,
2552		Description: description,
2553	}
2554
2555	mockNotificationChannel.err = nil
2556	mockNotificationChannel.reqs = nil
2557
2558	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2559
2560	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2561	var code string = "code3059181"
2562	var request = &monitoringpb.VerifyNotificationChannelRequest{
2563		Name: formattedName,
2564		Code: code,
2565	}
2566
2567	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2568	if err != nil {
2569		t.Fatal(err)
2570	}
2571
2572	resp, err := c.VerifyNotificationChannel(context.Background(), request)
2573
2574	if err != nil {
2575		t.Fatal(err)
2576	}
2577
2578	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2579		t.Errorf("wrong request %q, want %q", got, want)
2580	}
2581
2582	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2583		t.Errorf("wrong response %q, want %q)", got, want)
2584	}
2585}
2586
2587func TestNotificationChannelServiceVerifyNotificationChannelError(t *testing.T) {
2588	errCode := codes.PermissionDenied
2589	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2590
2591	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2592	var code string = "code3059181"
2593	var request = &monitoringpb.VerifyNotificationChannelRequest{
2594		Name: formattedName,
2595		Code: code,
2596	}
2597
2598	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2599	if err != nil {
2600		t.Fatal(err)
2601	}
2602
2603	resp, err := c.VerifyNotificationChannel(context.Background(), request)
2604
2605	if st, ok := gstatus.FromError(err); !ok {
2606		t.Errorf("got error %v, expected grpc error", err)
2607	} else if c := st.Code(); c != errCode {
2608		t.Errorf("got error code %q, want %q", c, errCode)
2609	}
2610	_ = resp
2611}
2612func TestServiceMonitoringServiceCreateService(t *testing.T) {
2613	var name string = "name3373707"
2614	var displayName string = "displayName1615086568"
2615	var expectedResponse = &monitoringpb.Service{
2616		Name:        name,
2617		DisplayName: displayName,
2618	}
2619
2620	mockServiceMonitoring.err = nil
2621	mockServiceMonitoring.reqs = nil
2622
2623	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2624
2625	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2626	var service *monitoringpb.Service = &monitoringpb.Service{}
2627	var request = &monitoringpb.CreateServiceRequest{
2628		Parent:  formattedParent,
2629		Service: service,
2630	}
2631
2632	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2633	if err != nil {
2634		t.Fatal(err)
2635	}
2636
2637	resp, err := c.CreateService(context.Background(), request)
2638
2639	if err != nil {
2640		t.Fatal(err)
2641	}
2642
2643	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2644		t.Errorf("wrong request %q, want %q", got, want)
2645	}
2646
2647	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2648		t.Errorf("wrong response %q, want %q)", got, want)
2649	}
2650}
2651
2652func TestServiceMonitoringServiceCreateServiceError(t *testing.T) {
2653	errCode := codes.PermissionDenied
2654	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2655
2656	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2657	var service *monitoringpb.Service = &monitoringpb.Service{}
2658	var request = &monitoringpb.CreateServiceRequest{
2659		Parent:  formattedParent,
2660		Service: service,
2661	}
2662
2663	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2664	if err != nil {
2665		t.Fatal(err)
2666	}
2667
2668	resp, err := c.CreateService(context.Background(), request)
2669
2670	if st, ok := gstatus.FromError(err); !ok {
2671		t.Errorf("got error %v, expected grpc error", err)
2672	} else if c := st.Code(); c != errCode {
2673		t.Errorf("got error code %q, want %q", c, errCode)
2674	}
2675	_ = resp
2676}
2677func TestServiceMonitoringServiceGetService(t *testing.T) {
2678	var name2 string = "name2-1052831874"
2679	var displayName string = "displayName1615086568"
2680	var expectedResponse = &monitoringpb.Service{
2681		Name:        name2,
2682		DisplayName: displayName,
2683	}
2684
2685	mockServiceMonitoring.err = nil
2686	mockServiceMonitoring.reqs = nil
2687
2688	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2689
2690	var formattedName string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2691	var request = &monitoringpb.GetServiceRequest{
2692		Name: formattedName,
2693	}
2694
2695	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2696	if err != nil {
2697		t.Fatal(err)
2698	}
2699
2700	resp, err := c.GetService(context.Background(), request)
2701
2702	if err != nil {
2703		t.Fatal(err)
2704	}
2705
2706	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2707		t.Errorf("wrong request %q, want %q", got, want)
2708	}
2709
2710	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2711		t.Errorf("wrong response %q, want %q)", got, want)
2712	}
2713}
2714
2715func TestServiceMonitoringServiceGetServiceError(t *testing.T) {
2716	errCode := codes.PermissionDenied
2717	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2718
2719	var formattedName string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2720	var request = &monitoringpb.GetServiceRequest{
2721		Name: formattedName,
2722	}
2723
2724	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2725	if err != nil {
2726		t.Fatal(err)
2727	}
2728
2729	resp, err := c.GetService(context.Background(), request)
2730
2731	if st, ok := gstatus.FromError(err); !ok {
2732		t.Errorf("got error %v, expected grpc error", err)
2733	} else if c := st.Code(); c != errCode {
2734		t.Errorf("got error code %q, want %q", c, errCode)
2735	}
2736	_ = resp
2737}
2738func TestServiceMonitoringServiceListServices(t *testing.T) {
2739	var nextPageToken string = ""
2740	var servicesElement *monitoringpb.Service = &monitoringpb.Service{}
2741	var services = []*monitoringpb.Service{servicesElement}
2742	var expectedResponse = &monitoringpb.ListServicesResponse{
2743		NextPageToken: nextPageToken,
2744		Services:      services,
2745	}
2746
2747	mockServiceMonitoring.err = nil
2748	mockServiceMonitoring.reqs = nil
2749
2750	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2751
2752	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2753	var request = &monitoringpb.ListServicesRequest{
2754		Parent: formattedParent,
2755	}
2756
2757	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2758	if err != nil {
2759		t.Fatal(err)
2760	}
2761
2762	resp, err := c.ListServices(context.Background(), request).Next()
2763
2764	if err != nil {
2765		t.Fatal(err)
2766	}
2767
2768	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2769		t.Errorf("wrong request %q, want %q", got, want)
2770	}
2771
2772	want := (interface{})(expectedResponse.Services[0])
2773	got := (interface{})(resp)
2774	var ok bool
2775
2776	switch want := (want).(type) {
2777	case proto.Message:
2778		ok = proto.Equal(want, got.(proto.Message))
2779	default:
2780		ok = want == got
2781	}
2782	if !ok {
2783		t.Errorf("wrong response %q, want %q)", got, want)
2784	}
2785}
2786
2787func TestServiceMonitoringServiceListServicesError(t *testing.T) {
2788	errCode := codes.PermissionDenied
2789	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2790
2791	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2792	var request = &monitoringpb.ListServicesRequest{
2793		Parent: formattedParent,
2794	}
2795
2796	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2797	if err != nil {
2798		t.Fatal(err)
2799	}
2800
2801	resp, err := c.ListServices(context.Background(), request).Next()
2802
2803	if st, ok := gstatus.FromError(err); !ok {
2804		t.Errorf("got error %v, expected grpc error", err)
2805	} else if c := st.Code(); c != errCode {
2806		t.Errorf("got error code %q, want %q", c, errCode)
2807	}
2808	_ = resp
2809}
2810func TestServiceMonitoringServiceUpdateService(t *testing.T) {
2811	var name string = "name3373707"
2812	var displayName string = "displayName1615086568"
2813	var expectedResponse = &monitoringpb.Service{
2814		Name:        name,
2815		DisplayName: displayName,
2816	}
2817
2818	mockServiceMonitoring.err = nil
2819	mockServiceMonitoring.reqs = nil
2820
2821	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2822
2823	var service *monitoringpb.Service = &monitoringpb.Service{}
2824	var request = &monitoringpb.UpdateServiceRequest{
2825		Service: service,
2826	}
2827
2828	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2829	if err != nil {
2830		t.Fatal(err)
2831	}
2832
2833	resp, err := c.UpdateService(context.Background(), request)
2834
2835	if err != nil {
2836		t.Fatal(err)
2837	}
2838
2839	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2840		t.Errorf("wrong request %q, want %q", got, want)
2841	}
2842
2843	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2844		t.Errorf("wrong response %q, want %q)", got, want)
2845	}
2846}
2847
2848func TestServiceMonitoringServiceUpdateServiceError(t *testing.T) {
2849	errCode := codes.PermissionDenied
2850	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2851
2852	var service *monitoringpb.Service = &monitoringpb.Service{}
2853	var request = &monitoringpb.UpdateServiceRequest{
2854		Service: service,
2855	}
2856
2857	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2858	if err != nil {
2859		t.Fatal(err)
2860	}
2861
2862	resp, err := c.UpdateService(context.Background(), request)
2863
2864	if st, ok := gstatus.FromError(err); !ok {
2865		t.Errorf("got error %v, expected grpc error", err)
2866	} else if c := st.Code(); c != errCode {
2867		t.Errorf("got error code %q, want %q", c, errCode)
2868	}
2869	_ = resp
2870}
2871func TestServiceMonitoringServiceDeleteService(t *testing.T) {
2872	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
2873
2874	mockServiceMonitoring.err = nil
2875	mockServiceMonitoring.reqs = nil
2876
2877	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2878
2879	var formattedName string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2880	var request = &monitoringpb.DeleteServiceRequest{
2881		Name: formattedName,
2882	}
2883
2884	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2885	if err != nil {
2886		t.Fatal(err)
2887	}
2888
2889	err = c.DeleteService(context.Background(), request)
2890
2891	if err != nil {
2892		t.Fatal(err)
2893	}
2894
2895	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2896		t.Errorf("wrong request %q, want %q", got, want)
2897	}
2898
2899}
2900
2901func TestServiceMonitoringServiceDeleteServiceError(t *testing.T) {
2902	errCode := codes.PermissionDenied
2903	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2904
2905	var formattedName string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2906	var request = &monitoringpb.DeleteServiceRequest{
2907		Name: formattedName,
2908	}
2909
2910	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2911	if err != nil {
2912		t.Fatal(err)
2913	}
2914
2915	err = c.DeleteService(context.Background(), request)
2916
2917	if st, ok := gstatus.FromError(err); !ok {
2918		t.Errorf("got error %v, expected grpc error", err)
2919	} else if c := st.Code(); c != errCode {
2920		t.Errorf("got error code %q, want %q", c, errCode)
2921	}
2922}
2923func TestServiceMonitoringServiceCreateServiceLevelObjective(t *testing.T) {
2924	var name string = "name3373707"
2925	var displayName string = "displayName1615086568"
2926	var goal float64 = 317825.0
2927	var expectedResponse = &monitoringpb.ServiceLevelObjective{
2928		Name:        name,
2929		DisplayName: displayName,
2930		Goal:        goal,
2931	}
2932
2933	mockServiceMonitoring.err = nil
2934	mockServiceMonitoring.reqs = nil
2935
2936	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
2937
2938	var formattedParent string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2939	var serviceLevelObjective *monitoringpb.ServiceLevelObjective = &monitoringpb.ServiceLevelObjective{}
2940	var request = &monitoringpb.CreateServiceLevelObjectiveRequest{
2941		Parent:                formattedParent,
2942		ServiceLevelObjective: serviceLevelObjective,
2943	}
2944
2945	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2946	if err != nil {
2947		t.Fatal(err)
2948	}
2949
2950	resp, err := c.CreateServiceLevelObjective(context.Background(), request)
2951
2952	if err != nil {
2953		t.Fatal(err)
2954	}
2955
2956	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
2957		t.Errorf("wrong request %q, want %q", got, want)
2958	}
2959
2960	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2961		t.Errorf("wrong response %q, want %q)", got, want)
2962	}
2963}
2964
2965func TestServiceMonitoringServiceCreateServiceLevelObjectiveError(t *testing.T) {
2966	errCode := codes.PermissionDenied
2967	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
2968
2969	var formattedParent string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
2970	var serviceLevelObjective *monitoringpb.ServiceLevelObjective = &monitoringpb.ServiceLevelObjective{}
2971	var request = &monitoringpb.CreateServiceLevelObjectiveRequest{
2972		Parent:                formattedParent,
2973		ServiceLevelObjective: serviceLevelObjective,
2974	}
2975
2976	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
2977	if err != nil {
2978		t.Fatal(err)
2979	}
2980
2981	resp, err := c.CreateServiceLevelObjective(context.Background(), request)
2982
2983	if st, ok := gstatus.FromError(err); !ok {
2984		t.Errorf("got error %v, expected grpc error", err)
2985	} else if c := st.Code(); c != errCode {
2986		t.Errorf("got error code %q, want %q", c, errCode)
2987	}
2988	_ = resp
2989}
2990func TestServiceMonitoringServiceGetServiceLevelObjective(t *testing.T) {
2991	var name2 string = "name2-1052831874"
2992	var displayName string = "displayName1615086568"
2993	var goal float64 = 317825.0
2994	var expectedResponse = &monitoringpb.ServiceLevelObjective{
2995		Name:        name2,
2996		DisplayName: displayName,
2997		Goal:        goal,
2998	}
2999
3000	mockServiceMonitoring.err = nil
3001	mockServiceMonitoring.reqs = nil
3002
3003	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
3004
3005	var formattedName string = fmt.Sprintf("projects/%s/services/%s/serviceLevelObjectives/%s", "[PROJECT]", "[SERVICE]", "[SERVICE_LEVEL_OBJECTIVE]")
3006	var request = &monitoringpb.GetServiceLevelObjectiveRequest{
3007		Name: formattedName,
3008	}
3009
3010	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3011	if err != nil {
3012		t.Fatal(err)
3013	}
3014
3015	resp, err := c.GetServiceLevelObjective(context.Background(), request)
3016
3017	if err != nil {
3018		t.Fatal(err)
3019	}
3020
3021	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
3022		t.Errorf("wrong request %q, want %q", got, want)
3023	}
3024
3025	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
3026		t.Errorf("wrong response %q, want %q)", got, want)
3027	}
3028}
3029
3030func TestServiceMonitoringServiceGetServiceLevelObjectiveError(t *testing.T) {
3031	errCode := codes.PermissionDenied
3032	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
3033
3034	var formattedName string = fmt.Sprintf("projects/%s/services/%s/serviceLevelObjectives/%s", "[PROJECT]", "[SERVICE]", "[SERVICE_LEVEL_OBJECTIVE]")
3035	var request = &monitoringpb.GetServiceLevelObjectiveRequest{
3036		Name: formattedName,
3037	}
3038
3039	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3040	if err != nil {
3041		t.Fatal(err)
3042	}
3043
3044	resp, err := c.GetServiceLevelObjective(context.Background(), request)
3045
3046	if st, ok := gstatus.FromError(err); !ok {
3047		t.Errorf("got error %v, expected grpc error", err)
3048	} else if c := st.Code(); c != errCode {
3049		t.Errorf("got error code %q, want %q", c, errCode)
3050	}
3051	_ = resp
3052}
3053func TestServiceMonitoringServiceListServiceLevelObjectives(t *testing.T) {
3054	var nextPageToken string = ""
3055	var serviceLevelObjectivesElement *monitoringpb.ServiceLevelObjective = &monitoringpb.ServiceLevelObjective{}
3056	var serviceLevelObjectives = []*monitoringpb.ServiceLevelObjective{serviceLevelObjectivesElement}
3057	var expectedResponse = &monitoringpb.ListServiceLevelObjectivesResponse{
3058		NextPageToken:          nextPageToken,
3059		ServiceLevelObjectives: serviceLevelObjectives,
3060	}
3061
3062	mockServiceMonitoring.err = nil
3063	mockServiceMonitoring.reqs = nil
3064
3065	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
3066
3067	var formattedParent string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
3068	var request = &monitoringpb.ListServiceLevelObjectivesRequest{
3069		Parent: formattedParent,
3070	}
3071
3072	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3073	if err != nil {
3074		t.Fatal(err)
3075	}
3076
3077	resp, err := c.ListServiceLevelObjectives(context.Background(), request).Next()
3078
3079	if err != nil {
3080		t.Fatal(err)
3081	}
3082
3083	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
3084		t.Errorf("wrong request %q, want %q", got, want)
3085	}
3086
3087	want := (interface{})(expectedResponse.ServiceLevelObjectives[0])
3088	got := (interface{})(resp)
3089	var ok bool
3090
3091	switch want := (want).(type) {
3092	case proto.Message:
3093		ok = proto.Equal(want, got.(proto.Message))
3094	default:
3095		ok = want == got
3096	}
3097	if !ok {
3098		t.Errorf("wrong response %q, want %q)", got, want)
3099	}
3100}
3101
3102func TestServiceMonitoringServiceListServiceLevelObjectivesError(t *testing.T) {
3103	errCode := codes.PermissionDenied
3104	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
3105
3106	var formattedParent string = fmt.Sprintf("projects/%s/services/%s", "[PROJECT]", "[SERVICE]")
3107	var request = &monitoringpb.ListServiceLevelObjectivesRequest{
3108		Parent: formattedParent,
3109	}
3110
3111	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3112	if err != nil {
3113		t.Fatal(err)
3114	}
3115
3116	resp, err := c.ListServiceLevelObjectives(context.Background(), request).Next()
3117
3118	if st, ok := gstatus.FromError(err); !ok {
3119		t.Errorf("got error %v, expected grpc error", err)
3120	} else if c := st.Code(); c != errCode {
3121		t.Errorf("got error code %q, want %q", c, errCode)
3122	}
3123	_ = resp
3124}
3125func TestServiceMonitoringServiceUpdateServiceLevelObjective(t *testing.T) {
3126	var name string = "name3373707"
3127	var displayName string = "displayName1615086568"
3128	var goal float64 = 317825.0
3129	var expectedResponse = &monitoringpb.ServiceLevelObjective{
3130		Name:        name,
3131		DisplayName: displayName,
3132		Goal:        goal,
3133	}
3134
3135	mockServiceMonitoring.err = nil
3136	mockServiceMonitoring.reqs = nil
3137
3138	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
3139
3140	var serviceLevelObjective *monitoringpb.ServiceLevelObjective = &monitoringpb.ServiceLevelObjective{}
3141	var request = &monitoringpb.UpdateServiceLevelObjectiveRequest{
3142		ServiceLevelObjective: serviceLevelObjective,
3143	}
3144
3145	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3146	if err != nil {
3147		t.Fatal(err)
3148	}
3149
3150	resp, err := c.UpdateServiceLevelObjective(context.Background(), request)
3151
3152	if err != nil {
3153		t.Fatal(err)
3154	}
3155
3156	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
3157		t.Errorf("wrong request %q, want %q", got, want)
3158	}
3159
3160	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
3161		t.Errorf("wrong response %q, want %q)", got, want)
3162	}
3163}
3164
3165func TestServiceMonitoringServiceUpdateServiceLevelObjectiveError(t *testing.T) {
3166	errCode := codes.PermissionDenied
3167	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
3168
3169	var serviceLevelObjective *monitoringpb.ServiceLevelObjective = &monitoringpb.ServiceLevelObjective{}
3170	var request = &monitoringpb.UpdateServiceLevelObjectiveRequest{
3171		ServiceLevelObjective: serviceLevelObjective,
3172	}
3173
3174	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3175	if err != nil {
3176		t.Fatal(err)
3177	}
3178
3179	resp, err := c.UpdateServiceLevelObjective(context.Background(), request)
3180
3181	if st, ok := gstatus.FromError(err); !ok {
3182		t.Errorf("got error %v, expected grpc error", err)
3183	} else if c := st.Code(); c != errCode {
3184		t.Errorf("got error code %q, want %q", c, errCode)
3185	}
3186	_ = resp
3187}
3188func TestServiceMonitoringServiceDeleteServiceLevelObjective(t *testing.T) {
3189	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
3190
3191	mockServiceMonitoring.err = nil
3192	mockServiceMonitoring.reqs = nil
3193
3194	mockServiceMonitoring.resps = append(mockServiceMonitoring.resps[:0], expectedResponse)
3195
3196	var formattedName string = fmt.Sprintf("projects/%s/services/%s/serviceLevelObjectives/%s", "[PROJECT]", "[SERVICE]", "[SERVICE_LEVEL_OBJECTIVE]")
3197	var request = &monitoringpb.DeleteServiceLevelObjectiveRequest{
3198		Name: formattedName,
3199	}
3200
3201	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3202	if err != nil {
3203		t.Fatal(err)
3204	}
3205
3206	err = c.DeleteServiceLevelObjective(context.Background(), request)
3207
3208	if err != nil {
3209		t.Fatal(err)
3210	}
3211
3212	if want, got := request, mockServiceMonitoring.reqs[0]; !proto.Equal(want, got) {
3213		t.Errorf("wrong request %q, want %q", got, want)
3214	}
3215
3216}
3217
3218func TestServiceMonitoringServiceDeleteServiceLevelObjectiveError(t *testing.T) {
3219	errCode := codes.PermissionDenied
3220	mockServiceMonitoring.err = gstatus.Error(errCode, "test error")
3221
3222	var formattedName string = fmt.Sprintf("projects/%s/services/%s/serviceLevelObjectives/%s", "[PROJECT]", "[SERVICE]", "[SERVICE_LEVEL_OBJECTIVE]")
3223	var request = &monitoringpb.DeleteServiceLevelObjectiveRequest{
3224		Name: formattedName,
3225	}
3226
3227	c, err := NewServiceMonitoringClient(context.Background(), clientOpt)
3228	if err != nil {
3229		t.Fatal(err)
3230	}
3231
3232	err = c.DeleteServiceLevelObjective(context.Background(), request)
3233
3234	if st, ok := gstatus.FromError(err); !ok {
3235		t.Errorf("got error %v, expected grpc error", err)
3236	} else if c := st.Code(); c != errCode {
3237		t.Errorf("got error code %q, want %q", c, errCode)
3238	}
3239}
3240func TestUptimeCheckServiceListUptimeCheckConfigs(t *testing.T) {
3241	var nextPageToken string = ""
3242	var totalSize int32 = 705419236
3243	var uptimeCheckConfigsElement *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
3244	var uptimeCheckConfigs = []*monitoringpb.UptimeCheckConfig{uptimeCheckConfigsElement}
3245	var expectedResponse = &monitoringpb.ListUptimeCheckConfigsResponse{
3246		NextPageToken:      nextPageToken,
3247		TotalSize:          totalSize,
3248		UptimeCheckConfigs: uptimeCheckConfigs,
3249	}
3250
3251	mockUptimeCheck.err = nil
3252	mockUptimeCheck.reqs = nil
3253
3254	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3255
3256	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
3257	var request = &monitoringpb.ListUptimeCheckConfigsRequest{
3258		Parent: formattedParent,
3259	}
3260
3261	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3262	if err != nil {
3263		t.Fatal(err)
3264	}
3265
3266	resp, err := c.ListUptimeCheckConfigs(context.Background(), request).Next()
3267
3268	if err != nil {
3269		t.Fatal(err)
3270	}
3271
3272	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3273		t.Errorf("wrong request %q, want %q", got, want)
3274	}
3275
3276	want := (interface{})(expectedResponse.UptimeCheckConfigs[0])
3277	got := (interface{})(resp)
3278	var ok bool
3279
3280	switch want := (want).(type) {
3281	case proto.Message:
3282		ok = proto.Equal(want, got.(proto.Message))
3283	default:
3284		ok = want == got
3285	}
3286	if !ok {
3287		t.Errorf("wrong response %q, want %q)", got, want)
3288	}
3289}
3290
3291func TestUptimeCheckServiceListUptimeCheckConfigsError(t *testing.T) {
3292	errCode := codes.PermissionDenied
3293	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3294
3295	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
3296	var request = &monitoringpb.ListUptimeCheckConfigsRequest{
3297		Parent: formattedParent,
3298	}
3299
3300	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3301	if err != nil {
3302		t.Fatal(err)
3303	}
3304
3305	resp, err := c.ListUptimeCheckConfigs(context.Background(), request).Next()
3306
3307	if st, ok := gstatus.FromError(err); !ok {
3308		t.Errorf("got error %v, expected grpc error", err)
3309	} else if c := st.Code(); c != errCode {
3310		t.Errorf("got error code %q, want %q", c, errCode)
3311	}
3312	_ = resp
3313}
3314func TestUptimeCheckServiceGetUptimeCheckConfig(t *testing.T) {
3315	var name2 string = "name2-1052831874"
3316	var displayName string = "displayName1615086568"
3317	var isInternal bool = true
3318	var expectedResponse = &monitoringpb.UptimeCheckConfig{
3319		Name:        name2,
3320		DisplayName: displayName,
3321		IsInternal:  isInternal,
3322	}
3323
3324	mockUptimeCheck.err = nil
3325	mockUptimeCheck.reqs = nil
3326
3327	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3328
3329	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
3330	var request = &monitoringpb.GetUptimeCheckConfigRequest{
3331		Name: formattedName,
3332	}
3333
3334	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3335	if err != nil {
3336		t.Fatal(err)
3337	}
3338
3339	resp, err := c.GetUptimeCheckConfig(context.Background(), request)
3340
3341	if err != nil {
3342		t.Fatal(err)
3343	}
3344
3345	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3346		t.Errorf("wrong request %q, want %q", got, want)
3347	}
3348
3349	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
3350		t.Errorf("wrong response %q, want %q)", got, want)
3351	}
3352}
3353
3354func TestUptimeCheckServiceGetUptimeCheckConfigError(t *testing.T) {
3355	errCode := codes.PermissionDenied
3356	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3357
3358	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
3359	var request = &monitoringpb.GetUptimeCheckConfigRequest{
3360		Name: formattedName,
3361	}
3362
3363	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3364	if err != nil {
3365		t.Fatal(err)
3366	}
3367
3368	resp, err := c.GetUptimeCheckConfig(context.Background(), request)
3369
3370	if st, ok := gstatus.FromError(err); !ok {
3371		t.Errorf("got error %v, expected grpc error", err)
3372	} else if c := st.Code(); c != errCode {
3373		t.Errorf("got error code %q, want %q", c, errCode)
3374	}
3375	_ = resp
3376}
3377func TestUptimeCheckServiceCreateUptimeCheckConfig(t *testing.T) {
3378	var name string = "name3373707"
3379	var displayName string = "displayName1615086568"
3380	var isInternal bool = true
3381	var expectedResponse = &monitoringpb.UptimeCheckConfig{
3382		Name:        name,
3383		DisplayName: displayName,
3384		IsInternal:  isInternal,
3385	}
3386
3387	mockUptimeCheck.err = nil
3388	mockUptimeCheck.reqs = nil
3389
3390	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3391
3392	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
3393	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
3394	var request = &monitoringpb.CreateUptimeCheckConfigRequest{
3395		Parent:            formattedParent,
3396		UptimeCheckConfig: uptimeCheckConfig,
3397	}
3398
3399	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3400	if err != nil {
3401		t.Fatal(err)
3402	}
3403
3404	resp, err := c.CreateUptimeCheckConfig(context.Background(), request)
3405
3406	if err != nil {
3407		t.Fatal(err)
3408	}
3409
3410	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3411		t.Errorf("wrong request %q, want %q", got, want)
3412	}
3413
3414	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
3415		t.Errorf("wrong response %q, want %q)", got, want)
3416	}
3417}
3418
3419func TestUptimeCheckServiceCreateUptimeCheckConfigError(t *testing.T) {
3420	errCode := codes.PermissionDenied
3421	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3422
3423	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
3424	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
3425	var request = &monitoringpb.CreateUptimeCheckConfigRequest{
3426		Parent:            formattedParent,
3427		UptimeCheckConfig: uptimeCheckConfig,
3428	}
3429
3430	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3431	if err != nil {
3432		t.Fatal(err)
3433	}
3434
3435	resp, err := c.CreateUptimeCheckConfig(context.Background(), request)
3436
3437	if st, ok := gstatus.FromError(err); !ok {
3438		t.Errorf("got error %v, expected grpc error", err)
3439	} else if c := st.Code(); c != errCode {
3440		t.Errorf("got error code %q, want %q", c, errCode)
3441	}
3442	_ = resp
3443}
3444func TestUptimeCheckServiceUpdateUptimeCheckConfig(t *testing.T) {
3445	var name string = "name3373707"
3446	var displayName string = "displayName1615086568"
3447	var isInternal bool = true
3448	var expectedResponse = &monitoringpb.UptimeCheckConfig{
3449		Name:        name,
3450		DisplayName: displayName,
3451		IsInternal:  isInternal,
3452	}
3453
3454	mockUptimeCheck.err = nil
3455	mockUptimeCheck.reqs = nil
3456
3457	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3458
3459	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
3460	var request = &monitoringpb.UpdateUptimeCheckConfigRequest{
3461		UptimeCheckConfig: uptimeCheckConfig,
3462	}
3463
3464	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3465	if err != nil {
3466		t.Fatal(err)
3467	}
3468
3469	resp, err := c.UpdateUptimeCheckConfig(context.Background(), request)
3470
3471	if err != nil {
3472		t.Fatal(err)
3473	}
3474
3475	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3476		t.Errorf("wrong request %q, want %q", got, want)
3477	}
3478
3479	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
3480		t.Errorf("wrong response %q, want %q)", got, want)
3481	}
3482}
3483
3484func TestUptimeCheckServiceUpdateUptimeCheckConfigError(t *testing.T) {
3485	errCode := codes.PermissionDenied
3486	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3487
3488	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
3489	var request = &monitoringpb.UpdateUptimeCheckConfigRequest{
3490		UptimeCheckConfig: uptimeCheckConfig,
3491	}
3492
3493	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3494	if err != nil {
3495		t.Fatal(err)
3496	}
3497
3498	resp, err := c.UpdateUptimeCheckConfig(context.Background(), request)
3499
3500	if st, ok := gstatus.FromError(err); !ok {
3501		t.Errorf("got error %v, expected grpc error", err)
3502	} else if c := st.Code(); c != errCode {
3503		t.Errorf("got error code %q, want %q", c, errCode)
3504	}
3505	_ = resp
3506}
3507func TestUptimeCheckServiceDeleteUptimeCheckConfig(t *testing.T) {
3508	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
3509
3510	mockUptimeCheck.err = nil
3511	mockUptimeCheck.reqs = nil
3512
3513	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3514
3515	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
3516	var request = &monitoringpb.DeleteUptimeCheckConfigRequest{
3517		Name: formattedName,
3518	}
3519
3520	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3521	if err != nil {
3522		t.Fatal(err)
3523	}
3524
3525	err = c.DeleteUptimeCheckConfig(context.Background(), request)
3526
3527	if err != nil {
3528		t.Fatal(err)
3529	}
3530
3531	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3532		t.Errorf("wrong request %q, want %q", got, want)
3533	}
3534
3535}
3536
3537func TestUptimeCheckServiceDeleteUptimeCheckConfigError(t *testing.T) {
3538	errCode := codes.PermissionDenied
3539	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3540
3541	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
3542	var request = &monitoringpb.DeleteUptimeCheckConfigRequest{
3543		Name: formattedName,
3544	}
3545
3546	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3547	if err != nil {
3548		t.Fatal(err)
3549	}
3550
3551	err = c.DeleteUptimeCheckConfig(context.Background(), request)
3552
3553	if st, ok := gstatus.FromError(err); !ok {
3554		t.Errorf("got error %v, expected grpc error", err)
3555	} else if c := st.Code(); c != errCode {
3556		t.Errorf("got error code %q, want %q", c, errCode)
3557	}
3558}
3559func TestUptimeCheckServiceListUptimeCheckIps(t *testing.T) {
3560	var nextPageToken string = ""
3561	var uptimeCheckIpsElement *monitoringpb.UptimeCheckIp = &monitoringpb.UptimeCheckIp{}
3562	var uptimeCheckIps = []*monitoringpb.UptimeCheckIp{uptimeCheckIpsElement}
3563	var expectedResponse = &monitoringpb.ListUptimeCheckIpsResponse{
3564		NextPageToken:  nextPageToken,
3565		UptimeCheckIps: uptimeCheckIps,
3566	}
3567
3568	mockUptimeCheck.err = nil
3569	mockUptimeCheck.reqs = nil
3570
3571	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
3572
3573	var request *monitoringpb.ListUptimeCheckIpsRequest = &monitoringpb.ListUptimeCheckIpsRequest{}
3574
3575	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3576	if err != nil {
3577		t.Fatal(err)
3578	}
3579
3580	resp, err := c.ListUptimeCheckIps(context.Background(), request).Next()
3581
3582	if err != nil {
3583		t.Fatal(err)
3584	}
3585
3586	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
3587		t.Errorf("wrong request %q, want %q", got, want)
3588	}
3589
3590	want := (interface{})(expectedResponse.UptimeCheckIps[0])
3591	got := (interface{})(resp)
3592	var ok bool
3593
3594	switch want := (want).(type) {
3595	case proto.Message:
3596		ok = proto.Equal(want, got.(proto.Message))
3597	default:
3598		ok = want == got
3599	}
3600	if !ok {
3601		t.Errorf("wrong response %q, want %q)", got, want)
3602	}
3603}
3604
3605func TestUptimeCheckServiceListUptimeCheckIpsError(t *testing.T) {
3606	errCode := codes.PermissionDenied
3607	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
3608
3609	var request *monitoringpb.ListUptimeCheckIpsRequest = &monitoringpb.ListUptimeCheckIpsRequest{}
3610
3611	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
3612	if err != nil {
3613		t.Fatal(err)
3614	}
3615
3616	resp, err := c.ListUptimeCheckIps(context.Background(), request).Next()
3617
3618	if st, ok := gstatus.FromError(err); !ok {
3619		t.Errorf("got error %v, expected grpc error", err)
3620	} else if c := st.Code(); c != errCode {
3621		t.Errorf("got error code %q, want %q", c, errCode)
3622	}
3623	_ = resp
3624}
3625