1// Copyright 2018 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// AUTO-GENERATED CODE. DO NOT EDIT.
16
17package monitoring
18
19import (
20	emptypb "github.com/golang/protobuf/ptypes/empty"
21	metricpb "google.golang.org/genproto/googleapis/api/metric"
22	monitoredrespb "google.golang.org/genproto/googleapis/api/monitoredres"
23	monitoringpb "google.golang.org/genproto/googleapis/monitoring/v3"
24)
25
26import (
27	"flag"
28	"fmt"
29	"io"
30	"log"
31	"net"
32	"os"
33	"strings"
34	"testing"
35
36	"github.com/golang/protobuf/proto"
37	"github.com/golang/protobuf/ptypes"
38	"golang.org/x/net/context"
39	"google.golang.org/api/option"
40	status "google.golang.org/genproto/googleapis/rpc/status"
41	"google.golang.org/grpc"
42	"google.golang.org/grpc/codes"
43	"google.golang.org/grpc/metadata"
44	gstatus "google.golang.org/grpc/status"
45)
46
47var _ = io.EOF
48var _ = ptypes.MarshalAny
49var _ status.Status
50
51type mockAlertPolicyServer struct {
52	// Embed for forward compatibility.
53	// Tests will keep working if more methods are added
54	// in the future.
55	monitoringpb.AlertPolicyServiceServer
56
57	reqs []proto.Message
58
59	// If set, all calls return this error.
60	err error
61
62	// responses to return if err == nil
63	resps []proto.Message
64}
65
66func (s *mockAlertPolicyServer) ListAlertPolicies(ctx context.Context, req *monitoringpb.ListAlertPoliciesRequest) (*monitoringpb.ListAlertPoliciesResponse, error) {
67	md, _ := metadata.FromIncomingContext(ctx)
68	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
69		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
70	}
71	s.reqs = append(s.reqs, req)
72	if s.err != nil {
73		return nil, s.err
74	}
75	return s.resps[0].(*monitoringpb.ListAlertPoliciesResponse), nil
76}
77
78func (s *mockAlertPolicyServer) GetAlertPolicy(ctx context.Context, req *monitoringpb.GetAlertPolicyRequest) (*monitoringpb.AlertPolicy, error) {
79	md, _ := metadata.FromIncomingContext(ctx)
80	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
81		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
82	}
83	s.reqs = append(s.reqs, req)
84	if s.err != nil {
85		return nil, s.err
86	}
87	return s.resps[0].(*monitoringpb.AlertPolicy), nil
88}
89
90func (s *mockAlertPolicyServer) CreateAlertPolicy(ctx context.Context, req *monitoringpb.CreateAlertPolicyRequest) (*monitoringpb.AlertPolicy, error) {
91	md, _ := metadata.FromIncomingContext(ctx)
92	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
93		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
94	}
95	s.reqs = append(s.reqs, req)
96	if s.err != nil {
97		return nil, s.err
98	}
99	return s.resps[0].(*monitoringpb.AlertPolicy), nil
100}
101
102func (s *mockAlertPolicyServer) DeleteAlertPolicy(ctx context.Context, req *monitoringpb.DeleteAlertPolicyRequest) (*emptypb.Empty, error) {
103	md, _ := metadata.FromIncomingContext(ctx)
104	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
105		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
106	}
107	s.reqs = append(s.reqs, req)
108	if s.err != nil {
109		return nil, s.err
110	}
111	return s.resps[0].(*emptypb.Empty), nil
112}
113
114func (s *mockAlertPolicyServer) UpdateAlertPolicy(ctx context.Context, req *monitoringpb.UpdateAlertPolicyRequest) (*monitoringpb.AlertPolicy, error) {
115	md, _ := metadata.FromIncomingContext(ctx)
116	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
117		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
118	}
119	s.reqs = append(s.reqs, req)
120	if s.err != nil {
121		return nil, s.err
122	}
123	return s.resps[0].(*monitoringpb.AlertPolicy), nil
124}
125
126type mockGroupServer struct {
127	// Embed for forward compatibility.
128	// Tests will keep working if more methods are added
129	// in the future.
130	monitoringpb.GroupServiceServer
131
132	reqs []proto.Message
133
134	// If set, all calls return this error.
135	err error
136
137	// responses to return if err == nil
138	resps []proto.Message
139}
140
141func (s *mockGroupServer) ListGroups(ctx context.Context, req *monitoringpb.ListGroupsRequest) (*monitoringpb.ListGroupsResponse, error) {
142	md, _ := metadata.FromIncomingContext(ctx)
143	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
144		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
145	}
146	s.reqs = append(s.reqs, req)
147	if s.err != nil {
148		return nil, s.err
149	}
150	return s.resps[0].(*monitoringpb.ListGroupsResponse), nil
151}
152
153func (s *mockGroupServer) GetGroup(ctx context.Context, req *monitoringpb.GetGroupRequest) (*monitoringpb.Group, error) {
154	md, _ := metadata.FromIncomingContext(ctx)
155	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
156		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
157	}
158	s.reqs = append(s.reqs, req)
159	if s.err != nil {
160		return nil, s.err
161	}
162	return s.resps[0].(*monitoringpb.Group), nil
163}
164
165func (s *mockGroupServer) CreateGroup(ctx context.Context, req *monitoringpb.CreateGroupRequest) (*monitoringpb.Group, error) {
166	md, _ := metadata.FromIncomingContext(ctx)
167	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
168		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
169	}
170	s.reqs = append(s.reqs, req)
171	if s.err != nil {
172		return nil, s.err
173	}
174	return s.resps[0].(*monitoringpb.Group), nil
175}
176
177func (s *mockGroupServer) UpdateGroup(ctx context.Context, req *monitoringpb.UpdateGroupRequest) (*monitoringpb.Group, error) {
178	md, _ := metadata.FromIncomingContext(ctx)
179	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
180		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
181	}
182	s.reqs = append(s.reqs, req)
183	if s.err != nil {
184		return nil, s.err
185	}
186	return s.resps[0].(*monitoringpb.Group), nil
187}
188
189func (s *mockGroupServer) DeleteGroup(ctx context.Context, req *monitoringpb.DeleteGroupRequest) (*emptypb.Empty, error) {
190	md, _ := metadata.FromIncomingContext(ctx)
191	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
192		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
193	}
194	s.reqs = append(s.reqs, req)
195	if s.err != nil {
196		return nil, s.err
197	}
198	return s.resps[0].(*emptypb.Empty), nil
199}
200
201func (s *mockGroupServer) ListGroupMembers(ctx context.Context, req *monitoringpb.ListGroupMembersRequest) (*monitoringpb.ListGroupMembersResponse, error) {
202	md, _ := metadata.FromIncomingContext(ctx)
203	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
204		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
205	}
206	s.reqs = append(s.reqs, req)
207	if s.err != nil {
208		return nil, s.err
209	}
210	return s.resps[0].(*monitoringpb.ListGroupMembersResponse), nil
211}
212
213type mockMetricServer struct {
214	// Embed for forward compatibility.
215	// Tests will keep working if more methods are added
216	// in the future.
217	monitoringpb.MetricServiceServer
218
219	reqs []proto.Message
220
221	// If set, all calls return this error.
222	err error
223
224	// responses to return if err == nil
225	resps []proto.Message
226}
227
228func (s *mockMetricServer) ListMonitoredResourceDescriptors(ctx context.Context, req *monitoringpb.ListMonitoredResourceDescriptorsRequest) (*monitoringpb.ListMonitoredResourceDescriptorsResponse, error) {
229	md, _ := metadata.FromIncomingContext(ctx)
230	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
231		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
232	}
233	s.reqs = append(s.reqs, req)
234	if s.err != nil {
235		return nil, s.err
236	}
237	return s.resps[0].(*monitoringpb.ListMonitoredResourceDescriptorsResponse), nil
238}
239
240func (s *mockMetricServer) GetMonitoredResourceDescriptor(ctx context.Context, req *monitoringpb.GetMonitoredResourceDescriptorRequest) (*monitoredrespb.MonitoredResourceDescriptor, error) {
241	md, _ := metadata.FromIncomingContext(ctx)
242	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
243		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
244	}
245	s.reqs = append(s.reqs, req)
246	if s.err != nil {
247		return nil, s.err
248	}
249	return s.resps[0].(*monitoredrespb.MonitoredResourceDescriptor), nil
250}
251
252func (s *mockMetricServer) ListMetricDescriptors(ctx context.Context, req *monitoringpb.ListMetricDescriptorsRequest) (*monitoringpb.ListMetricDescriptorsResponse, error) {
253	md, _ := metadata.FromIncomingContext(ctx)
254	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
255		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
256	}
257	s.reqs = append(s.reqs, req)
258	if s.err != nil {
259		return nil, s.err
260	}
261	return s.resps[0].(*monitoringpb.ListMetricDescriptorsResponse), nil
262}
263
264func (s *mockMetricServer) GetMetricDescriptor(ctx context.Context, req *monitoringpb.GetMetricDescriptorRequest) (*metricpb.MetricDescriptor, error) {
265	md, _ := metadata.FromIncomingContext(ctx)
266	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
267		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
268	}
269	s.reqs = append(s.reqs, req)
270	if s.err != nil {
271		return nil, s.err
272	}
273	return s.resps[0].(*metricpb.MetricDescriptor), nil
274}
275
276func (s *mockMetricServer) CreateMetricDescriptor(ctx context.Context, req *monitoringpb.CreateMetricDescriptorRequest) (*metricpb.MetricDescriptor, error) {
277	md, _ := metadata.FromIncomingContext(ctx)
278	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
279		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
280	}
281	s.reqs = append(s.reqs, req)
282	if s.err != nil {
283		return nil, s.err
284	}
285	return s.resps[0].(*metricpb.MetricDescriptor), nil
286}
287
288func (s *mockMetricServer) DeleteMetricDescriptor(ctx context.Context, req *monitoringpb.DeleteMetricDescriptorRequest) (*emptypb.Empty, error) {
289	md, _ := metadata.FromIncomingContext(ctx)
290	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
291		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
292	}
293	s.reqs = append(s.reqs, req)
294	if s.err != nil {
295		return nil, s.err
296	}
297	return s.resps[0].(*emptypb.Empty), nil
298}
299
300func (s *mockMetricServer) ListTimeSeries(ctx context.Context, req *monitoringpb.ListTimeSeriesRequest) (*monitoringpb.ListTimeSeriesResponse, error) {
301	md, _ := metadata.FromIncomingContext(ctx)
302	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
303		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
304	}
305	s.reqs = append(s.reqs, req)
306	if s.err != nil {
307		return nil, s.err
308	}
309	return s.resps[0].(*monitoringpb.ListTimeSeriesResponse), nil
310}
311
312func (s *mockMetricServer) CreateTimeSeries(ctx context.Context, req *monitoringpb.CreateTimeSeriesRequest) (*emptypb.Empty, error) {
313	md, _ := metadata.FromIncomingContext(ctx)
314	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
315		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
316	}
317	s.reqs = append(s.reqs, req)
318	if s.err != nil {
319		return nil, s.err
320	}
321	return s.resps[0].(*emptypb.Empty), nil
322}
323
324type mockNotificationChannelServer struct {
325	// Embed for forward compatibility.
326	// Tests will keep working if more methods are added
327	// in the future.
328	monitoringpb.NotificationChannelServiceServer
329
330	reqs []proto.Message
331
332	// If set, all calls return this error.
333	err error
334
335	// responses to return if err == nil
336	resps []proto.Message
337}
338
339func (s *mockNotificationChannelServer) ListNotificationChannelDescriptors(ctx context.Context, req *monitoringpb.ListNotificationChannelDescriptorsRequest) (*monitoringpb.ListNotificationChannelDescriptorsResponse, error) {
340	md, _ := metadata.FromIncomingContext(ctx)
341	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
342		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
343	}
344	s.reqs = append(s.reqs, req)
345	if s.err != nil {
346		return nil, s.err
347	}
348	return s.resps[0].(*monitoringpb.ListNotificationChannelDescriptorsResponse), nil
349}
350
351func (s *mockNotificationChannelServer) GetNotificationChannelDescriptor(ctx context.Context, req *monitoringpb.GetNotificationChannelDescriptorRequest) (*monitoringpb.NotificationChannelDescriptor, error) {
352	md, _ := metadata.FromIncomingContext(ctx)
353	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
354		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
355	}
356	s.reqs = append(s.reqs, req)
357	if s.err != nil {
358		return nil, s.err
359	}
360	return s.resps[0].(*monitoringpb.NotificationChannelDescriptor), nil
361}
362
363func (s *mockNotificationChannelServer) ListNotificationChannels(ctx context.Context, req *monitoringpb.ListNotificationChannelsRequest) (*monitoringpb.ListNotificationChannelsResponse, error) {
364	md, _ := metadata.FromIncomingContext(ctx)
365	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
366		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
367	}
368	s.reqs = append(s.reqs, req)
369	if s.err != nil {
370		return nil, s.err
371	}
372	return s.resps[0].(*monitoringpb.ListNotificationChannelsResponse), nil
373}
374
375func (s *mockNotificationChannelServer) GetNotificationChannel(ctx context.Context, req *monitoringpb.GetNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
376	md, _ := metadata.FromIncomingContext(ctx)
377	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
378		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
379	}
380	s.reqs = append(s.reqs, req)
381	if s.err != nil {
382		return nil, s.err
383	}
384	return s.resps[0].(*monitoringpb.NotificationChannel), nil
385}
386
387func (s *mockNotificationChannelServer) CreateNotificationChannel(ctx context.Context, req *monitoringpb.CreateNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
388	md, _ := metadata.FromIncomingContext(ctx)
389	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
390		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
391	}
392	s.reqs = append(s.reqs, req)
393	if s.err != nil {
394		return nil, s.err
395	}
396	return s.resps[0].(*monitoringpb.NotificationChannel), nil
397}
398
399func (s *mockNotificationChannelServer) UpdateNotificationChannel(ctx context.Context, req *monitoringpb.UpdateNotificationChannelRequest) (*monitoringpb.NotificationChannel, error) {
400	md, _ := metadata.FromIncomingContext(ctx)
401	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
402		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
403	}
404	s.reqs = append(s.reqs, req)
405	if s.err != nil {
406		return nil, s.err
407	}
408	return s.resps[0].(*monitoringpb.NotificationChannel), nil
409}
410
411func (s *mockNotificationChannelServer) DeleteNotificationChannel(ctx context.Context, req *monitoringpb.DeleteNotificationChannelRequest) (*emptypb.Empty, error) {
412	md, _ := metadata.FromIncomingContext(ctx)
413	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
414		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
415	}
416	s.reqs = append(s.reqs, req)
417	if s.err != nil {
418		return nil, s.err
419	}
420	return s.resps[0].(*emptypb.Empty), nil
421}
422
423type mockUptimeCheckServer struct {
424	// Embed for forward compatibility.
425	// Tests will keep working if more methods are added
426	// in the future.
427	monitoringpb.UptimeCheckServiceServer
428
429	reqs []proto.Message
430
431	// If set, all calls return this error.
432	err error
433
434	// responses to return if err == nil
435	resps []proto.Message
436}
437
438func (s *mockUptimeCheckServer) ListUptimeCheckConfigs(ctx context.Context, req *monitoringpb.ListUptimeCheckConfigsRequest) (*monitoringpb.ListUptimeCheckConfigsResponse, error) {
439	md, _ := metadata.FromIncomingContext(ctx)
440	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
441		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
442	}
443	s.reqs = append(s.reqs, req)
444	if s.err != nil {
445		return nil, s.err
446	}
447	return s.resps[0].(*monitoringpb.ListUptimeCheckConfigsResponse), nil
448}
449
450func (s *mockUptimeCheckServer) GetUptimeCheckConfig(ctx context.Context, req *monitoringpb.GetUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
451	md, _ := metadata.FromIncomingContext(ctx)
452	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
453		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
454	}
455	s.reqs = append(s.reqs, req)
456	if s.err != nil {
457		return nil, s.err
458	}
459	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
460}
461
462func (s *mockUptimeCheckServer) CreateUptimeCheckConfig(ctx context.Context, req *monitoringpb.CreateUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
463	md, _ := metadata.FromIncomingContext(ctx)
464	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
465		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
466	}
467	s.reqs = append(s.reqs, req)
468	if s.err != nil {
469		return nil, s.err
470	}
471	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
472}
473
474func (s *mockUptimeCheckServer) UpdateUptimeCheckConfig(ctx context.Context, req *monitoringpb.UpdateUptimeCheckConfigRequest) (*monitoringpb.UptimeCheckConfig, error) {
475	md, _ := metadata.FromIncomingContext(ctx)
476	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
477		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
478	}
479	s.reqs = append(s.reqs, req)
480	if s.err != nil {
481		return nil, s.err
482	}
483	return s.resps[0].(*monitoringpb.UptimeCheckConfig), nil
484}
485
486func (s *mockUptimeCheckServer) DeleteUptimeCheckConfig(ctx context.Context, req *monitoringpb.DeleteUptimeCheckConfigRequest) (*emptypb.Empty, error) {
487	md, _ := metadata.FromIncomingContext(ctx)
488	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
489		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
490	}
491	s.reqs = append(s.reqs, req)
492	if s.err != nil {
493		return nil, s.err
494	}
495	return s.resps[0].(*emptypb.Empty), nil
496}
497
498func (s *mockUptimeCheckServer) ListUptimeCheckIps(ctx context.Context, req *monitoringpb.ListUptimeCheckIpsRequest) (*monitoringpb.ListUptimeCheckIpsResponse, error) {
499	md, _ := metadata.FromIncomingContext(ctx)
500	if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") {
501		return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg)
502	}
503	s.reqs = append(s.reqs, req)
504	if s.err != nil {
505		return nil, s.err
506	}
507	return s.resps[0].(*monitoringpb.ListUptimeCheckIpsResponse), nil
508}
509
510// clientOpt is the option tests should use to connect to the test server.
511// It is initialized by TestMain.
512var clientOpt option.ClientOption
513
514var (
515	mockAlertPolicy         mockAlertPolicyServer
516	mockGroup               mockGroupServer
517	mockMetric              mockMetricServer
518	mockNotificationChannel mockNotificationChannelServer
519	mockUptimeCheck         mockUptimeCheckServer
520)
521
522func TestMain(m *testing.M) {
523	flag.Parse()
524
525	serv := grpc.NewServer()
526	monitoringpb.RegisterAlertPolicyServiceServer(serv, &mockAlertPolicy)
527	monitoringpb.RegisterGroupServiceServer(serv, &mockGroup)
528	monitoringpb.RegisterMetricServiceServer(serv, &mockMetric)
529	monitoringpb.RegisterNotificationChannelServiceServer(serv, &mockNotificationChannel)
530	monitoringpb.RegisterUptimeCheckServiceServer(serv, &mockUptimeCheck)
531
532	lis, err := net.Listen("tcp", "localhost:0")
533	if err != nil {
534		log.Fatal(err)
535	}
536	go serv.Serve(lis)
537
538	conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure())
539	if err != nil {
540		log.Fatal(err)
541	}
542	clientOpt = option.WithGRPCConn(conn)
543
544	os.Exit(m.Run())
545}
546
547func TestAlertPolicyServiceListAlertPolicies(t *testing.T) {
548	var nextPageToken string = ""
549	var alertPoliciesElement *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
550	var alertPolicies = []*monitoringpb.AlertPolicy{alertPoliciesElement}
551	var expectedResponse = &monitoringpb.ListAlertPoliciesResponse{
552		NextPageToken: nextPageToken,
553		AlertPolicies: alertPolicies,
554	}
555
556	mockAlertPolicy.err = nil
557	mockAlertPolicy.reqs = nil
558
559	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
560
561	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
562	var request = &monitoringpb.ListAlertPoliciesRequest{
563		Name: formattedName,
564	}
565
566	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
567	if err != nil {
568		t.Fatal(err)
569	}
570
571	resp, err := c.ListAlertPolicies(context.Background(), request).Next()
572
573	if err != nil {
574		t.Fatal(err)
575	}
576
577	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
578		t.Errorf("wrong request %q, want %q", got, want)
579	}
580
581	want := (interface{})(expectedResponse.AlertPolicies[0])
582	got := (interface{})(resp)
583	var ok bool
584
585	switch want := (want).(type) {
586	case proto.Message:
587		ok = proto.Equal(want, got.(proto.Message))
588	default:
589		ok = want == got
590	}
591	if !ok {
592		t.Errorf("wrong response %q, want %q)", got, want)
593	}
594}
595
596func TestAlertPolicyServiceListAlertPoliciesError(t *testing.T) {
597	errCode := codes.PermissionDenied
598	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
599
600	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
601	var request = &monitoringpb.ListAlertPoliciesRequest{
602		Name: formattedName,
603	}
604
605	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
606	if err != nil {
607		t.Fatal(err)
608	}
609
610	resp, err := c.ListAlertPolicies(context.Background(), request).Next()
611
612	if st, ok := gstatus.FromError(err); !ok {
613		t.Errorf("got error %v, expected grpc error", err)
614	} else if c := st.Code(); c != errCode {
615		t.Errorf("got error code %q, want %q", c, errCode)
616	}
617	_ = resp
618}
619func TestAlertPolicyServiceGetAlertPolicy(t *testing.T) {
620	var name2 string = "name2-1052831874"
621	var displayName string = "displayName1615086568"
622	var expectedResponse = &monitoringpb.AlertPolicy{
623		Name:        name2,
624		DisplayName: displayName,
625	}
626
627	mockAlertPolicy.err = nil
628	mockAlertPolicy.reqs = nil
629
630	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
631
632	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
633	var request = &monitoringpb.GetAlertPolicyRequest{
634		Name: formattedName,
635	}
636
637	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
638	if err != nil {
639		t.Fatal(err)
640	}
641
642	resp, err := c.GetAlertPolicy(context.Background(), request)
643
644	if err != nil {
645		t.Fatal(err)
646	}
647
648	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
649		t.Errorf("wrong request %q, want %q", got, want)
650	}
651
652	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
653		t.Errorf("wrong response %q, want %q)", got, want)
654	}
655}
656
657func TestAlertPolicyServiceGetAlertPolicyError(t *testing.T) {
658	errCode := codes.PermissionDenied
659	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
660
661	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
662	var request = &monitoringpb.GetAlertPolicyRequest{
663		Name: formattedName,
664	}
665
666	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
667	if err != nil {
668		t.Fatal(err)
669	}
670
671	resp, err := c.GetAlertPolicy(context.Background(), request)
672
673	if st, ok := gstatus.FromError(err); !ok {
674		t.Errorf("got error %v, expected grpc error", err)
675	} else if c := st.Code(); c != errCode {
676		t.Errorf("got error code %q, want %q", c, errCode)
677	}
678	_ = resp
679}
680func TestAlertPolicyServiceCreateAlertPolicy(t *testing.T) {
681	var name2 string = "name2-1052831874"
682	var displayName string = "displayName1615086568"
683	var expectedResponse = &monitoringpb.AlertPolicy{
684		Name:        name2,
685		DisplayName: displayName,
686	}
687
688	mockAlertPolicy.err = nil
689	mockAlertPolicy.reqs = nil
690
691	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
692
693	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
694	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
695	var request = &monitoringpb.CreateAlertPolicyRequest{
696		Name:        formattedName,
697		AlertPolicy: alertPolicy,
698	}
699
700	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
701	if err != nil {
702		t.Fatal(err)
703	}
704
705	resp, err := c.CreateAlertPolicy(context.Background(), request)
706
707	if err != nil {
708		t.Fatal(err)
709	}
710
711	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
712		t.Errorf("wrong request %q, want %q", got, want)
713	}
714
715	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
716		t.Errorf("wrong response %q, want %q)", got, want)
717	}
718}
719
720func TestAlertPolicyServiceCreateAlertPolicyError(t *testing.T) {
721	errCode := codes.PermissionDenied
722	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
723
724	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
725	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
726	var request = &monitoringpb.CreateAlertPolicyRequest{
727		Name:        formattedName,
728		AlertPolicy: alertPolicy,
729	}
730
731	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
732	if err != nil {
733		t.Fatal(err)
734	}
735
736	resp, err := c.CreateAlertPolicy(context.Background(), request)
737
738	if st, ok := gstatus.FromError(err); !ok {
739		t.Errorf("got error %v, expected grpc error", err)
740	} else if c := st.Code(); c != errCode {
741		t.Errorf("got error code %q, want %q", c, errCode)
742	}
743	_ = resp
744}
745func TestAlertPolicyServiceDeleteAlertPolicy(t *testing.T) {
746	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
747
748	mockAlertPolicy.err = nil
749	mockAlertPolicy.reqs = nil
750
751	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
752
753	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
754	var request = &monitoringpb.DeleteAlertPolicyRequest{
755		Name: formattedName,
756	}
757
758	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
759	if err != nil {
760		t.Fatal(err)
761	}
762
763	err = c.DeleteAlertPolicy(context.Background(), request)
764
765	if err != nil {
766		t.Fatal(err)
767	}
768
769	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
770		t.Errorf("wrong request %q, want %q", got, want)
771	}
772
773}
774
775func TestAlertPolicyServiceDeleteAlertPolicyError(t *testing.T) {
776	errCode := codes.PermissionDenied
777	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
778
779	var formattedName string = fmt.Sprintf("projects/%s/alertPolicies/%s", "[PROJECT]", "[ALERT_POLICY]")
780	var request = &monitoringpb.DeleteAlertPolicyRequest{
781		Name: formattedName,
782	}
783
784	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
785	if err != nil {
786		t.Fatal(err)
787	}
788
789	err = c.DeleteAlertPolicy(context.Background(), request)
790
791	if st, ok := gstatus.FromError(err); !ok {
792		t.Errorf("got error %v, expected grpc error", err)
793	} else if c := st.Code(); c != errCode {
794		t.Errorf("got error code %q, want %q", c, errCode)
795	}
796}
797func TestAlertPolicyServiceUpdateAlertPolicy(t *testing.T) {
798	var name string = "name3373707"
799	var displayName string = "displayName1615086568"
800	var expectedResponse = &monitoringpb.AlertPolicy{
801		Name:        name,
802		DisplayName: displayName,
803	}
804
805	mockAlertPolicy.err = nil
806	mockAlertPolicy.reqs = nil
807
808	mockAlertPolicy.resps = append(mockAlertPolicy.resps[:0], expectedResponse)
809
810	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
811	var request = &monitoringpb.UpdateAlertPolicyRequest{
812		AlertPolicy: alertPolicy,
813	}
814
815	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
816	if err != nil {
817		t.Fatal(err)
818	}
819
820	resp, err := c.UpdateAlertPolicy(context.Background(), request)
821
822	if err != nil {
823		t.Fatal(err)
824	}
825
826	if want, got := request, mockAlertPolicy.reqs[0]; !proto.Equal(want, got) {
827		t.Errorf("wrong request %q, want %q", got, want)
828	}
829
830	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
831		t.Errorf("wrong response %q, want %q)", got, want)
832	}
833}
834
835func TestAlertPolicyServiceUpdateAlertPolicyError(t *testing.T) {
836	errCode := codes.PermissionDenied
837	mockAlertPolicy.err = gstatus.Error(errCode, "test error")
838
839	var alertPolicy *monitoringpb.AlertPolicy = &monitoringpb.AlertPolicy{}
840	var request = &monitoringpb.UpdateAlertPolicyRequest{
841		AlertPolicy: alertPolicy,
842	}
843
844	c, err := NewAlertPolicyClient(context.Background(), clientOpt)
845	if err != nil {
846		t.Fatal(err)
847	}
848
849	resp, err := c.UpdateAlertPolicy(context.Background(), request)
850
851	if st, ok := gstatus.FromError(err); !ok {
852		t.Errorf("got error %v, expected grpc error", err)
853	} else if c := st.Code(); c != errCode {
854		t.Errorf("got error code %q, want %q", c, errCode)
855	}
856	_ = resp
857}
858func TestGroupServiceListGroups(t *testing.T) {
859	var nextPageToken string = ""
860	var groupElement *monitoringpb.Group = &monitoringpb.Group{}
861	var group = []*monitoringpb.Group{groupElement}
862	var expectedResponse = &monitoringpb.ListGroupsResponse{
863		NextPageToken: nextPageToken,
864		Group:         group,
865	}
866
867	mockGroup.err = nil
868	mockGroup.reqs = nil
869
870	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
871
872	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
873	var request = &monitoringpb.ListGroupsRequest{
874		Name: formattedName,
875	}
876
877	c, err := NewGroupClient(context.Background(), clientOpt)
878	if err != nil {
879		t.Fatal(err)
880	}
881
882	resp, err := c.ListGroups(context.Background(), request).Next()
883
884	if err != nil {
885		t.Fatal(err)
886	}
887
888	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
889		t.Errorf("wrong request %q, want %q", got, want)
890	}
891
892	want := (interface{})(expectedResponse.Group[0])
893	got := (interface{})(resp)
894	var ok bool
895
896	switch want := (want).(type) {
897	case proto.Message:
898		ok = proto.Equal(want, got.(proto.Message))
899	default:
900		ok = want == got
901	}
902	if !ok {
903		t.Errorf("wrong response %q, want %q)", got, want)
904	}
905}
906
907func TestGroupServiceListGroupsError(t *testing.T) {
908	errCode := codes.PermissionDenied
909	mockGroup.err = gstatus.Error(errCode, "test error")
910
911	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
912	var request = &monitoringpb.ListGroupsRequest{
913		Name: formattedName,
914	}
915
916	c, err := NewGroupClient(context.Background(), clientOpt)
917	if err != nil {
918		t.Fatal(err)
919	}
920
921	resp, err := c.ListGroups(context.Background(), request).Next()
922
923	if st, ok := gstatus.FromError(err); !ok {
924		t.Errorf("got error %v, expected grpc error", err)
925	} else if c := st.Code(); c != errCode {
926		t.Errorf("got error code %q, want %q", c, errCode)
927	}
928	_ = resp
929}
930func TestGroupServiceGetGroup(t *testing.T) {
931	var name2 string = "name2-1052831874"
932	var displayName string = "displayName1615086568"
933	var parentName string = "parentName1015022848"
934	var filter string = "filter-1274492040"
935	var isCluster bool = false
936	var expectedResponse = &monitoringpb.Group{
937		Name:        name2,
938		DisplayName: displayName,
939		ParentName:  parentName,
940		Filter:      filter,
941		IsCluster:   isCluster,
942	}
943
944	mockGroup.err = nil
945	mockGroup.reqs = nil
946
947	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
948
949	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
950	var request = &monitoringpb.GetGroupRequest{
951		Name: formattedName,
952	}
953
954	c, err := NewGroupClient(context.Background(), clientOpt)
955	if err != nil {
956		t.Fatal(err)
957	}
958
959	resp, err := c.GetGroup(context.Background(), request)
960
961	if err != nil {
962		t.Fatal(err)
963	}
964
965	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
966		t.Errorf("wrong request %q, want %q", got, want)
967	}
968
969	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
970		t.Errorf("wrong response %q, want %q)", got, want)
971	}
972}
973
974func TestGroupServiceGetGroupError(t *testing.T) {
975	errCode := codes.PermissionDenied
976	mockGroup.err = gstatus.Error(errCode, "test error")
977
978	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
979	var request = &monitoringpb.GetGroupRequest{
980		Name: formattedName,
981	}
982
983	c, err := NewGroupClient(context.Background(), clientOpt)
984	if err != nil {
985		t.Fatal(err)
986	}
987
988	resp, err := c.GetGroup(context.Background(), request)
989
990	if st, ok := gstatus.FromError(err); !ok {
991		t.Errorf("got error %v, expected grpc error", err)
992	} else if c := st.Code(); c != errCode {
993		t.Errorf("got error code %q, want %q", c, errCode)
994	}
995	_ = resp
996}
997func TestGroupServiceCreateGroup(t *testing.T) {
998	var name2 string = "name2-1052831874"
999	var displayName string = "displayName1615086568"
1000	var parentName string = "parentName1015022848"
1001	var filter string = "filter-1274492040"
1002	var isCluster bool = false
1003	var expectedResponse = &monitoringpb.Group{
1004		Name:        name2,
1005		DisplayName: displayName,
1006		ParentName:  parentName,
1007		Filter:      filter,
1008		IsCluster:   isCluster,
1009	}
1010
1011	mockGroup.err = nil
1012	mockGroup.reqs = nil
1013
1014	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1015
1016	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1017	var group *monitoringpb.Group = &monitoringpb.Group{}
1018	var request = &monitoringpb.CreateGroupRequest{
1019		Name:  formattedName,
1020		Group: group,
1021	}
1022
1023	c, err := NewGroupClient(context.Background(), clientOpt)
1024	if err != nil {
1025		t.Fatal(err)
1026	}
1027
1028	resp, err := c.CreateGroup(context.Background(), request)
1029
1030	if err != nil {
1031		t.Fatal(err)
1032	}
1033
1034	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1035		t.Errorf("wrong request %q, want %q", got, want)
1036	}
1037
1038	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1039		t.Errorf("wrong response %q, want %q)", got, want)
1040	}
1041}
1042
1043func TestGroupServiceCreateGroupError(t *testing.T) {
1044	errCode := codes.PermissionDenied
1045	mockGroup.err = gstatus.Error(errCode, "test error")
1046
1047	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1048	var group *monitoringpb.Group = &monitoringpb.Group{}
1049	var request = &monitoringpb.CreateGroupRequest{
1050		Name:  formattedName,
1051		Group: group,
1052	}
1053
1054	c, err := NewGroupClient(context.Background(), clientOpt)
1055	if err != nil {
1056		t.Fatal(err)
1057	}
1058
1059	resp, err := c.CreateGroup(context.Background(), request)
1060
1061	if st, ok := gstatus.FromError(err); !ok {
1062		t.Errorf("got error %v, expected grpc error", err)
1063	} else if c := st.Code(); c != errCode {
1064		t.Errorf("got error code %q, want %q", c, errCode)
1065	}
1066	_ = resp
1067}
1068func TestGroupServiceUpdateGroup(t *testing.T) {
1069	var name string = "name3373707"
1070	var displayName string = "displayName1615086568"
1071	var parentName string = "parentName1015022848"
1072	var filter string = "filter-1274492040"
1073	var isCluster bool = false
1074	var expectedResponse = &monitoringpb.Group{
1075		Name:        name,
1076		DisplayName: displayName,
1077		ParentName:  parentName,
1078		Filter:      filter,
1079		IsCluster:   isCluster,
1080	}
1081
1082	mockGroup.err = nil
1083	mockGroup.reqs = nil
1084
1085	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1086
1087	var group *monitoringpb.Group = &monitoringpb.Group{}
1088	var request = &monitoringpb.UpdateGroupRequest{
1089		Group: group,
1090	}
1091
1092	c, err := NewGroupClient(context.Background(), clientOpt)
1093	if err != nil {
1094		t.Fatal(err)
1095	}
1096
1097	resp, err := c.UpdateGroup(context.Background(), request)
1098
1099	if err != nil {
1100		t.Fatal(err)
1101	}
1102
1103	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1104		t.Errorf("wrong request %q, want %q", got, want)
1105	}
1106
1107	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1108		t.Errorf("wrong response %q, want %q)", got, want)
1109	}
1110}
1111
1112func TestGroupServiceUpdateGroupError(t *testing.T) {
1113	errCode := codes.PermissionDenied
1114	mockGroup.err = gstatus.Error(errCode, "test error")
1115
1116	var group *monitoringpb.Group = &monitoringpb.Group{}
1117	var request = &monitoringpb.UpdateGroupRequest{
1118		Group: group,
1119	}
1120
1121	c, err := NewGroupClient(context.Background(), clientOpt)
1122	if err != nil {
1123		t.Fatal(err)
1124	}
1125
1126	resp, err := c.UpdateGroup(context.Background(), request)
1127
1128	if st, ok := gstatus.FromError(err); !ok {
1129		t.Errorf("got error %v, expected grpc error", err)
1130	} else if c := st.Code(); c != errCode {
1131		t.Errorf("got error code %q, want %q", c, errCode)
1132	}
1133	_ = resp
1134}
1135func TestGroupServiceDeleteGroup(t *testing.T) {
1136	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1137
1138	mockGroup.err = nil
1139	mockGroup.reqs = nil
1140
1141	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1142
1143	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1144	var request = &monitoringpb.DeleteGroupRequest{
1145		Name: formattedName,
1146	}
1147
1148	c, err := NewGroupClient(context.Background(), clientOpt)
1149	if err != nil {
1150		t.Fatal(err)
1151	}
1152
1153	err = c.DeleteGroup(context.Background(), request)
1154
1155	if err != nil {
1156		t.Fatal(err)
1157	}
1158
1159	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1160		t.Errorf("wrong request %q, want %q", got, want)
1161	}
1162
1163}
1164
1165func TestGroupServiceDeleteGroupError(t *testing.T) {
1166	errCode := codes.PermissionDenied
1167	mockGroup.err = gstatus.Error(errCode, "test error")
1168
1169	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1170	var request = &monitoringpb.DeleteGroupRequest{
1171		Name: formattedName,
1172	}
1173
1174	c, err := NewGroupClient(context.Background(), clientOpt)
1175	if err != nil {
1176		t.Fatal(err)
1177	}
1178
1179	err = c.DeleteGroup(context.Background(), request)
1180
1181	if st, ok := gstatus.FromError(err); !ok {
1182		t.Errorf("got error %v, expected grpc error", err)
1183	} else if c := st.Code(); c != errCode {
1184		t.Errorf("got error code %q, want %q", c, errCode)
1185	}
1186}
1187func TestGroupServiceListGroupMembers(t *testing.T) {
1188	var nextPageToken string = ""
1189	var totalSize int32 = 705419236
1190	var membersElement *monitoredrespb.MonitoredResource = &monitoredrespb.MonitoredResource{}
1191	var members = []*monitoredrespb.MonitoredResource{membersElement}
1192	var expectedResponse = &monitoringpb.ListGroupMembersResponse{
1193		NextPageToken: nextPageToken,
1194		TotalSize:     totalSize,
1195		Members:       members,
1196	}
1197
1198	mockGroup.err = nil
1199	mockGroup.reqs = nil
1200
1201	mockGroup.resps = append(mockGroup.resps[:0], expectedResponse)
1202
1203	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1204	var request = &monitoringpb.ListGroupMembersRequest{
1205		Name: formattedName,
1206	}
1207
1208	c, err := NewGroupClient(context.Background(), clientOpt)
1209	if err != nil {
1210		t.Fatal(err)
1211	}
1212
1213	resp, err := c.ListGroupMembers(context.Background(), request).Next()
1214
1215	if err != nil {
1216		t.Fatal(err)
1217	}
1218
1219	if want, got := request, mockGroup.reqs[0]; !proto.Equal(want, got) {
1220		t.Errorf("wrong request %q, want %q", got, want)
1221	}
1222
1223	want := (interface{})(expectedResponse.Members[0])
1224	got := (interface{})(resp)
1225	var ok bool
1226
1227	switch want := (want).(type) {
1228	case proto.Message:
1229		ok = proto.Equal(want, got.(proto.Message))
1230	default:
1231		ok = want == got
1232	}
1233	if !ok {
1234		t.Errorf("wrong response %q, want %q)", got, want)
1235	}
1236}
1237
1238func TestGroupServiceListGroupMembersError(t *testing.T) {
1239	errCode := codes.PermissionDenied
1240	mockGroup.err = gstatus.Error(errCode, "test error")
1241
1242	var formattedName string = fmt.Sprintf("projects/%s/groups/%s", "[PROJECT]", "[GROUP]")
1243	var request = &monitoringpb.ListGroupMembersRequest{
1244		Name: formattedName,
1245	}
1246
1247	c, err := NewGroupClient(context.Background(), clientOpt)
1248	if err != nil {
1249		t.Fatal(err)
1250	}
1251
1252	resp, err := c.ListGroupMembers(context.Background(), request).Next()
1253
1254	if st, ok := gstatus.FromError(err); !ok {
1255		t.Errorf("got error %v, expected grpc error", err)
1256	} else if c := st.Code(); c != errCode {
1257		t.Errorf("got error code %q, want %q", c, errCode)
1258	}
1259	_ = resp
1260}
1261func TestMetricServiceListMonitoredResourceDescriptors(t *testing.T) {
1262	var nextPageToken string = ""
1263	var resourceDescriptorsElement *monitoredrespb.MonitoredResourceDescriptor = &monitoredrespb.MonitoredResourceDescriptor{}
1264	var resourceDescriptors = []*monitoredrespb.MonitoredResourceDescriptor{resourceDescriptorsElement}
1265	var expectedResponse = &monitoringpb.ListMonitoredResourceDescriptorsResponse{
1266		NextPageToken:       nextPageToken,
1267		ResourceDescriptors: resourceDescriptors,
1268	}
1269
1270	mockMetric.err = nil
1271	mockMetric.reqs = nil
1272
1273	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1274
1275	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1276	var request = &monitoringpb.ListMonitoredResourceDescriptorsRequest{
1277		Name: formattedName,
1278	}
1279
1280	c, err := NewMetricClient(context.Background(), clientOpt)
1281	if err != nil {
1282		t.Fatal(err)
1283	}
1284
1285	resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next()
1286
1287	if err != nil {
1288		t.Fatal(err)
1289	}
1290
1291	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1292		t.Errorf("wrong request %q, want %q", got, want)
1293	}
1294
1295	want := (interface{})(expectedResponse.ResourceDescriptors[0])
1296	got := (interface{})(resp)
1297	var ok bool
1298
1299	switch want := (want).(type) {
1300	case proto.Message:
1301		ok = proto.Equal(want, got.(proto.Message))
1302	default:
1303		ok = want == got
1304	}
1305	if !ok {
1306		t.Errorf("wrong response %q, want %q)", got, want)
1307	}
1308}
1309
1310func TestMetricServiceListMonitoredResourceDescriptorsError(t *testing.T) {
1311	errCode := codes.PermissionDenied
1312	mockMetric.err = gstatus.Error(errCode, "test error")
1313
1314	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1315	var request = &monitoringpb.ListMonitoredResourceDescriptorsRequest{
1316		Name: formattedName,
1317	}
1318
1319	c, err := NewMetricClient(context.Background(), clientOpt)
1320	if err != nil {
1321		t.Fatal(err)
1322	}
1323
1324	resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next()
1325
1326	if st, ok := gstatus.FromError(err); !ok {
1327		t.Errorf("got error %v, expected grpc error", err)
1328	} else if c := st.Code(); c != errCode {
1329		t.Errorf("got error code %q, want %q", c, errCode)
1330	}
1331	_ = resp
1332}
1333func TestMetricServiceGetMonitoredResourceDescriptor(t *testing.T) {
1334	var name2 string = "name2-1052831874"
1335	var type_ string = "type3575610"
1336	var displayName string = "displayName1615086568"
1337	var description string = "description-1724546052"
1338	var expectedResponse = &monitoredrespb.MonitoredResourceDescriptor{
1339		Name:        name2,
1340		Type:        type_,
1341		DisplayName: displayName,
1342		Description: description,
1343	}
1344
1345	mockMetric.err = nil
1346	mockMetric.reqs = nil
1347
1348	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1349
1350	var formattedName string = fmt.Sprintf("projects/%s/monitoredResourceDescriptors/%s", "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]")
1351	var request = &monitoringpb.GetMonitoredResourceDescriptorRequest{
1352		Name: formattedName,
1353	}
1354
1355	c, err := NewMetricClient(context.Background(), clientOpt)
1356	if err != nil {
1357		t.Fatal(err)
1358	}
1359
1360	resp, err := c.GetMonitoredResourceDescriptor(context.Background(), request)
1361
1362	if err != nil {
1363		t.Fatal(err)
1364	}
1365
1366	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1367		t.Errorf("wrong request %q, want %q", got, want)
1368	}
1369
1370	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1371		t.Errorf("wrong response %q, want %q)", got, want)
1372	}
1373}
1374
1375func TestMetricServiceGetMonitoredResourceDescriptorError(t *testing.T) {
1376	errCode := codes.PermissionDenied
1377	mockMetric.err = gstatus.Error(errCode, "test error")
1378
1379	var formattedName string = fmt.Sprintf("projects/%s/monitoredResourceDescriptors/%s", "[PROJECT]", "[MONITORED_RESOURCE_DESCRIPTOR]")
1380	var request = &monitoringpb.GetMonitoredResourceDescriptorRequest{
1381		Name: formattedName,
1382	}
1383
1384	c, err := NewMetricClient(context.Background(), clientOpt)
1385	if err != nil {
1386		t.Fatal(err)
1387	}
1388
1389	resp, err := c.GetMonitoredResourceDescriptor(context.Background(), request)
1390
1391	if st, ok := gstatus.FromError(err); !ok {
1392		t.Errorf("got error %v, expected grpc error", err)
1393	} else if c := st.Code(); c != errCode {
1394		t.Errorf("got error code %q, want %q", c, errCode)
1395	}
1396	_ = resp
1397}
1398func TestMetricServiceListMetricDescriptors(t *testing.T) {
1399	var nextPageToken string = ""
1400	var metricDescriptorsElement *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1401	var metricDescriptors = []*metricpb.MetricDescriptor{metricDescriptorsElement}
1402	var expectedResponse = &monitoringpb.ListMetricDescriptorsResponse{
1403		NextPageToken:     nextPageToken,
1404		MetricDescriptors: metricDescriptors,
1405	}
1406
1407	mockMetric.err = nil
1408	mockMetric.reqs = nil
1409
1410	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1411
1412	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1413	var request = &monitoringpb.ListMetricDescriptorsRequest{
1414		Name: formattedName,
1415	}
1416
1417	c, err := NewMetricClient(context.Background(), clientOpt)
1418	if err != nil {
1419		t.Fatal(err)
1420	}
1421
1422	resp, err := c.ListMetricDescriptors(context.Background(), request).Next()
1423
1424	if err != nil {
1425		t.Fatal(err)
1426	}
1427
1428	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1429		t.Errorf("wrong request %q, want %q", got, want)
1430	}
1431
1432	want := (interface{})(expectedResponse.MetricDescriptors[0])
1433	got := (interface{})(resp)
1434	var ok bool
1435
1436	switch want := (want).(type) {
1437	case proto.Message:
1438		ok = proto.Equal(want, got.(proto.Message))
1439	default:
1440		ok = want == got
1441	}
1442	if !ok {
1443		t.Errorf("wrong response %q, want %q)", got, want)
1444	}
1445}
1446
1447func TestMetricServiceListMetricDescriptorsError(t *testing.T) {
1448	errCode := codes.PermissionDenied
1449	mockMetric.err = gstatus.Error(errCode, "test error")
1450
1451	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1452	var request = &monitoringpb.ListMetricDescriptorsRequest{
1453		Name: formattedName,
1454	}
1455
1456	c, err := NewMetricClient(context.Background(), clientOpt)
1457	if err != nil {
1458		t.Fatal(err)
1459	}
1460
1461	resp, err := c.ListMetricDescriptors(context.Background(), request).Next()
1462
1463	if st, ok := gstatus.FromError(err); !ok {
1464		t.Errorf("got error %v, expected grpc error", err)
1465	} else if c := st.Code(); c != errCode {
1466		t.Errorf("got error code %q, want %q", c, errCode)
1467	}
1468	_ = resp
1469}
1470func TestMetricServiceGetMetricDescriptor(t *testing.T) {
1471	var name2 string = "name2-1052831874"
1472	var type_ string = "type3575610"
1473	var unit string = "unit3594628"
1474	var description string = "description-1724546052"
1475	var displayName string = "displayName1615086568"
1476	var expectedResponse = &metricpb.MetricDescriptor{
1477		Name:        name2,
1478		Type:        type_,
1479		Unit:        unit,
1480		Description: description,
1481		DisplayName: displayName,
1482	}
1483
1484	mockMetric.err = nil
1485	mockMetric.reqs = nil
1486
1487	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1488
1489	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1490	var request = &monitoringpb.GetMetricDescriptorRequest{
1491		Name: formattedName,
1492	}
1493
1494	c, err := NewMetricClient(context.Background(), clientOpt)
1495	if err != nil {
1496		t.Fatal(err)
1497	}
1498
1499	resp, err := c.GetMetricDescriptor(context.Background(), request)
1500
1501	if err != nil {
1502		t.Fatal(err)
1503	}
1504
1505	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1506		t.Errorf("wrong request %q, want %q", got, want)
1507	}
1508
1509	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1510		t.Errorf("wrong response %q, want %q)", got, want)
1511	}
1512}
1513
1514func TestMetricServiceGetMetricDescriptorError(t *testing.T) {
1515	errCode := codes.PermissionDenied
1516	mockMetric.err = gstatus.Error(errCode, "test error")
1517
1518	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1519	var request = &monitoringpb.GetMetricDescriptorRequest{
1520		Name: formattedName,
1521	}
1522
1523	c, err := NewMetricClient(context.Background(), clientOpt)
1524	if err != nil {
1525		t.Fatal(err)
1526	}
1527
1528	resp, err := c.GetMetricDescriptor(context.Background(), request)
1529
1530	if st, ok := gstatus.FromError(err); !ok {
1531		t.Errorf("got error %v, expected grpc error", err)
1532	} else if c := st.Code(); c != errCode {
1533		t.Errorf("got error code %q, want %q", c, errCode)
1534	}
1535	_ = resp
1536}
1537func TestMetricServiceCreateMetricDescriptor(t *testing.T) {
1538	var name2 string = "name2-1052831874"
1539	var type_ string = "type3575610"
1540	var unit string = "unit3594628"
1541	var description string = "description-1724546052"
1542	var displayName string = "displayName1615086568"
1543	var expectedResponse = &metricpb.MetricDescriptor{
1544		Name:        name2,
1545		Type:        type_,
1546		Unit:        unit,
1547		Description: description,
1548		DisplayName: displayName,
1549	}
1550
1551	mockMetric.err = nil
1552	mockMetric.reqs = nil
1553
1554	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1555
1556	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1557	var metricDescriptor *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1558	var request = &monitoringpb.CreateMetricDescriptorRequest{
1559		Name:             formattedName,
1560		MetricDescriptor: metricDescriptor,
1561	}
1562
1563	c, err := NewMetricClient(context.Background(), clientOpt)
1564	if err != nil {
1565		t.Fatal(err)
1566	}
1567
1568	resp, err := c.CreateMetricDescriptor(context.Background(), request)
1569
1570	if err != nil {
1571		t.Fatal(err)
1572	}
1573
1574	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1575		t.Errorf("wrong request %q, want %q", got, want)
1576	}
1577
1578	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1579		t.Errorf("wrong response %q, want %q)", got, want)
1580	}
1581}
1582
1583func TestMetricServiceCreateMetricDescriptorError(t *testing.T) {
1584	errCode := codes.PermissionDenied
1585	mockMetric.err = gstatus.Error(errCode, "test error")
1586
1587	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1588	var metricDescriptor *metricpb.MetricDescriptor = &metricpb.MetricDescriptor{}
1589	var request = &monitoringpb.CreateMetricDescriptorRequest{
1590		Name:             formattedName,
1591		MetricDescriptor: metricDescriptor,
1592	}
1593
1594	c, err := NewMetricClient(context.Background(), clientOpt)
1595	if err != nil {
1596		t.Fatal(err)
1597	}
1598
1599	resp, err := c.CreateMetricDescriptor(context.Background(), request)
1600
1601	if st, ok := gstatus.FromError(err); !ok {
1602		t.Errorf("got error %v, expected grpc error", err)
1603	} else if c := st.Code(); c != errCode {
1604		t.Errorf("got error code %q, want %q", c, errCode)
1605	}
1606	_ = resp
1607}
1608func TestMetricServiceDeleteMetricDescriptor(t *testing.T) {
1609	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1610
1611	mockMetric.err = nil
1612	mockMetric.reqs = nil
1613
1614	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1615
1616	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1617	var request = &monitoringpb.DeleteMetricDescriptorRequest{
1618		Name: formattedName,
1619	}
1620
1621	c, err := NewMetricClient(context.Background(), clientOpt)
1622	if err != nil {
1623		t.Fatal(err)
1624	}
1625
1626	err = c.DeleteMetricDescriptor(context.Background(), request)
1627
1628	if err != nil {
1629		t.Fatal(err)
1630	}
1631
1632	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1633		t.Errorf("wrong request %q, want %q", got, want)
1634	}
1635
1636}
1637
1638func TestMetricServiceDeleteMetricDescriptorError(t *testing.T) {
1639	errCode := codes.PermissionDenied
1640	mockMetric.err = gstatus.Error(errCode, "test error")
1641
1642	var formattedName string = fmt.Sprintf("projects/%s/metricDescriptors/%s", "[PROJECT]", "[METRIC_DESCRIPTOR]")
1643	var request = &monitoringpb.DeleteMetricDescriptorRequest{
1644		Name: formattedName,
1645	}
1646
1647	c, err := NewMetricClient(context.Background(), clientOpt)
1648	if err != nil {
1649		t.Fatal(err)
1650	}
1651
1652	err = c.DeleteMetricDescriptor(context.Background(), request)
1653
1654	if st, ok := gstatus.FromError(err); !ok {
1655		t.Errorf("got error %v, expected grpc error", err)
1656	} else if c := st.Code(); c != errCode {
1657		t.Errorf("got error code %q, want %q", c, errCode)
1658	}
1659}
1660func TestMetricServiceListTimeSeries(t *testing.T) {
1661	var nextPageToken string = ""
1662	var timeSeriesElement *monitoringpb.TimeSeries = &monitoringpb.TimeSeries{}
1663	var timeSeries = []*monitoringpb.TimeSeries{timeSeriesElement}
1664	var expectedResponse = &monitoringpb.ListTimeSeriesResponse{
1665		NextPageToken: nextPageToken,
1666		TimeSeries:    timeSeries,
1667	}
1668
1669	mockMetric.err = nil
1670	mockMetric.reqs = nil
1671
1672	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1673
1674	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1675	var filter string = "filter-1274492040"
1676	var interval *monitoringpb.TimeInterval = &monitoringpb.TimeInterval{}
1677	var view monitoringpb.ListTimeSeriesRequest_TimeSeriesView = monitoringpb.ListTimeSeriesRequest_FULL
1678	var request = &monitoringpb.ListTimeSeriesRequest{
1679		Name:     formattedName,
1680		Filter:   filter,
1681		Interval: interval,
1682		View:     view,
1683	}
1684
1685	c, err := NewMetricClient(context.Background(), clientOpt)
1686	if err != nil {
1687		t.Fatal(err)
1688	}
1689
1690	resp, err := c.ListTimeSeries(context.Background(), request).Next()
1691
1692	if err != nil {
1693		t.Fatal(err)
1694	}
1695
1696	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1697		t.Errorf("wrong request %q, want %q", got, want)
1698	}
1699
1700	want := (interface{})(expectedResponse.TimeSeries[0])
1701	got := (interface{})(resp)
1702	var ok bool
1703
1704	switch want := (want).(type) {
1705	case proto.Message:
1706		ok = proto.Equal(want, got.(proto.Message))
1707	default:
1708		ok = want == got
1709	}
1710	if !ok {
1711		t.Errorf("wrong response %q, want %q)", got, want)
1712	}
1713}
1714
1715func TestMetricServiceListTimeSeriesError(t *testing.T) {
1716	errCode := codes.PermissionDenied
1717	mockMetric.err = gstatus.Error(errCode, "test error")
1718
1719	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1720	var filter string = "filter-1274492040"
1721	var interval *monitoringpb.TimeInterval = &monitoringpb.TimeInterval{}
1722	var view monitoringpb.ListTimeSeriesRequest_TimeSeriesView = monitoringpb.ListTimeSeriesRequest_FULL
1723	var request = &monitoringpb.ListTimeSeriesRequest{
1724		Name:     formattedName,
1725		Filter:   filter,
1726		Interval: interval,
1727		View:     view,
1728	}
1729
1730	c, err := NewMetricClient(context.Background(), clientOpt)
1731	if err != nil {
1732		t.Fatal(err)
1733	}
1734
1735	resp, err := c.ListTimeSeries(context.Background(), request).Next()
1736
1737	if st, ok := gstatus.FromError(err); !ok {
1738		t.Errorf("got error %v, expected grpc error", err)
1739	} else if c := st.Code(); c != errCode {
1740		t.Errorf("got error code %q, want %q", c, errCode)
1741	}
1742	_ = resp
1743}
1744func TestMetricServiceCreateTimeSeries(t *testing.T) {
1745	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
1746
1747	mockMetric.err = nil
1748	mockMetric.reqs = nil
1749
1750	mockMetric.resps = append(mockMetric.resps[:0], expectedResponse)
1751
1752	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1753	var timeSeries []*monitoringpb.TimeSeries = nil
1754	var request = &monitoringpb.CreateTimeSeriesRequest{
1755		Name:       formattedName,
1756		TimeSeries: timeSeries,
1757	}
1758
1759	c, err := NewMetricClient(context.Background(), clientOpt)
1760	if err != nil {
1761		t.Fatal(err)
1762	}
1763
1764	err = c.CreateTimeSeries(context.Background(), request)
1765
1766	if err != nil {
1767		t.Fatal(err)
1768	}
1769
1770	if want, got := request, mockMetric.reqs[0]; !proto.Equal(want, got) {
1771		t.Errorf("wrong request %q, want %q", got, want)
1772	}
1773
1774}
1775
1776func TestMetricServiceCreateTimeSeriesError(t *testing.T) {
1777	errCode := codes.PermissionDenied
1778	mockMetric.err = gstatus.Error(errCode, "test error")
1779
1780	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1781	var timeSeries []*monitoringpb.TimeSeries = nil
1782	var request = &monitoringpb.CreateTimeSeriesRequest{
1783		Name:       formattedName,
1784		TimeSeries: timeSeries,
1785	}
1786
1787	c, err := NewMetricClient(context.Background(), clientOpt)
1788	if err != nil {
1789		t.Fatal(err)
1790	}
1791
1792	err = c.CreateTimeSeries(context.Background(), request)
1793
1794	if st, ok := gstatus.FromError(err); !ok {
1795		t.Errorf("got error %v, expected grpc error", err)
1796	} else if c := st.Code(); c != errCode {
1797		t.Errorf("got error code %q, want %q", c, errCode)
1798	}
1799}
1800func TestNotificationChannelServiceListNotificationChannelDescriptors(t *testing.T) {
1801	var nextPageToken string = ""
1802	var channelDescriptorsElement *monitoringpb.NotificationChannelDescriptor = &monitoringpb.NotificationChannelDescriptor{}
1803	var channelDescriptors = []*monitoringpb.NotificationChannelDescriptor{channelDescriptorsElement}
1804	var expectedResponse = &monitoringpb.ListNotificationChannelDescriptorsResponse{
1805		NextPageToken:      nextPageToken,
1806		ChannelDescriptors: channelDescriptors,
1807	}
1808
1809	mockNotificationChannel.err = nil
1810	mockNotificationChannel.reqs = nil
1811
1812	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
1813
1814	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1815	var request = &monitoringpb.ListNotificationChannelDescriptorsRequest{
1816		Name: formattedName,
1817	}
1818
1819	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1820	if err != nil {
1821		t.Fatal(err)
1822	}
1823
1824	resp, err := c.ListNotificationChannelDescriptors(context.Background(), request).Next()
1825
1826	if err != nil {
1827		t.Fatal(err)
1828	}
1829
1830	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
1831		t.Errorf("wrong request %q, want %q", got, want)
1832	}
1833
1834	want := (interface{})(expectedResponse.ChannelDescriptors[0])
1835	got := (interface{})(resp)
1836	var ok bool
1837
1838	switch want := (want).(type) {
1839	case proto.Message:
1840		ok = proto.Equal(want, got.(proto.Message))
1841	default:
1842		ok = want == got
1843	}
1844	if !ok {
1845		t.Errorf("wrong response %q, want %q)", got, want)
1846	}
1847}
1848
1849func TestNotificationChannelServiceListNotificationChannelDescriptorsError(t *testing.T) {
1850	errCode := codes.PermissionDenied
1851	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
1852
1853	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1854	var request = &monitoringpb.ListNotificationChannelDescriptorsRequest{
1855		Name: formattedName,
1856	}
1857
1858	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1859	if err != nil {
1860		t.Fatal(err)
1861	}
1862
1863	resp, err := c.ListNotificationChannelDescriptors(context.Background(), request).Next()
1864
1865	if st, ok := gstatus.FromError(err); !ok {
1866		t.Errorf("got error %v, expected grpc error", err)
1867	} else if c := st.Code(); c != errCode {
1868		t.Errorf("got error code %q, want %q", c, errCode)
1869	}
1870	_ = resp
1871}
1872func TestNotificationChannelServiceGetNotificationChannelDescriptor(t *testing.T) {
1873	var name2 string = "name2-1052831874"
1874	var type_ string = "type3575610"
1875	var displayName string = "displayName1615086568"
1876	var description string = "description-1724546052"
1877	var expectedResponse = &monitoringpb.NotificationChannelDescriptor{
1878		Name:        name2,
1879		Type:        type_,
1880		DisplayName: displayName,
1881		Description: description,
1882	}
1883
1884	mockNotificationChannel.err = nil
1885	mockNotificationChannel.reqs = nil
1886
1887	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
1888
1889	var formattedName string = fmt.Sprintf("projects/%s/notificationChannelDescriptors/%s", "[PROJECT]", "[CHANNEL_DESCRIPTOR]")
1890	var request = &monitoringpb.GetNotificationChannelDescriptorRequest{
1891		Name: formattedName,
1892	}
1893
1894	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1895	if err != nil {
1896		t.Fatal(err)
1897	}
1898
1899	resp, err := c.GetNotificationChannelDescriptor(context.Background(), request)
1900
1901	if err != nil {
1902		t.Fatal(err)
1903	}
1904
1905	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
1906		t.Errorf("wrong request %q, want %q", got, want)
1907	}
1908
1909	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
1910		t.Errorf("wrong response %q, want %q)", got, want)
1911	}
1912}
1913
1914func TestNotificationChannelServiceGetNotificationChannelDescriptorError(t *testing.T) {
1915	errCode := codes.PermissionDenied
1916	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
1917
1918	var formattedName string = fmt.Sprintf("projects/%s/notificationChannelDescriptors/%s", "[PROJECT]", "[CHANNEL_DESCRIPTOR]")
1919	var request = &monitoringpb.GetNotificationChannelDescriptorRequest{
1920		Name: formattedName,
1921	}
1922
1923	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1924	if err != nil {
1925		t.Fatal(err)
1926	}
1927
1928	resp, err := c.GetNotificationChannelDescriptor(context.Background(), request)
1929
1930	if st, ok := gstatus.FromError(err); !ok {
1931		t.Errorf("got error %v, expected grpc error", err)
1932	} else if c := st.Code(); c != errCode {
1933		t.Errorf("got error code %q, want %q", c, errCode)
1934	}
1935	_ = resp
1936}
1937func TestNotificationChannelServiceListNotificationChannels(t *testing.T) {
1938	var nextPageToken string = ""
1939	var notificationChannelsElement *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
1940	var notificationChannels = []*monitoringpb.NotificationChannel{notificationChannelsElement}
1941	var expectedResponse = &monitoringpb.ListNotificationChannelsResponse{
1942		NextPageToken:        nextPageToken,
1943		NotificationChannels: notificationChannels,
1944	}
1945
1946	mockNotificationChannel.err = nil
1947	mockNotificationChannel.reqs = nil
1948
1949	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
1950
1951	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1952	var request = &monitoringpb.ListNotificationChannelsRequest{
1953		Name: formattedName,
1954	}
1955
1956	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1957	if err != nil {
1958		t.Fatal(err)
1959	}
1960
1961	resp, err := c.ListNotificationChannels(context.Background(), request).Next()
1962
1963	if err != nil {
1964		t.Fatal(err)
1965	}
1966
1967	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
1968		t.Errorf("wrong request %q, want %q", got, want)
1969	}
1970
1971	want := (interface{})(expectedResponse.NotificationChannels[0])
1972	got := (interface{})(resp)
1973	var ok bool
1974
1975	switch want := (want).(type) {
1976	case proto.Message:
1977		ok = proto.Equal(want, got.(proto.Message))
1978	default:
1979		ok = want == got
1980	}
1981	if !ok {
1982		t.Errorf("wrong response %q, want %q)", got, want)
1983	}
1984}
1985
1986func TestNotificationChannelServiceListNotificationChannelsError(t *testing.T) {
1987	errCode := codes.PermissionDenied
1988	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
1989
1990	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
1991	var request = &monitoringpb.ListNotificationChannelsRequest{
1992		Name: formattedName,
1993	}
1994
1995	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
1996	if err != nil {
1997		t.Fatal(err)
1998	}
1999
2000	resp, err := c.ListNotificationChannels(context.Background(), request).Next()
2001
2002	if st, ok := gstatus.FromError(err); !ok {
2003		t.Errorf("got error %v, expected grpc error", err)
2004	} else if c := st.Code(); c != errCode {
2005		t.Errorf("got error code %q, want %q", c, errCode)
2006	}
2007	_ = resp
2008}
2009func TestNotificationChannelServiceGetNotificationChannel(t *testing.T) {
2010	var type_ string = "type3575610"
2011	var name2 string = "name2-1052831874"
2012	var displayName string = "displayName1615086568"
2013	var description string = "description-1724546052"
2014	var expectedResponse = &monitoringpb.NotificationChannel{
2015		Type:        type_,
2016		Name:        name2,
2017		DisplayName: displayName,
2018		Description: description,
2019	}
2020
2021	mockNotificationChannel.err = nil
2022	mockNotificationChannel.reqs = nil
2023
2024	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2025
2026	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2027	var request = &monitoringpb.GetNotificationChannelRequest{
2028		Name: formattedName,
2029	}
2030
2031	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2032	if err != nil {
2033		t.Fatal(err)
2034	}
2035
2036	resp, err := c.GetNotificationChannel(context.Background(), request)
2037
2038	if err != nil {
2039		t.Fatal(err)
2040	}
2041
2042	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2043		t.Errorf("wrong request %q, want %q", got, want)
2044	}
2045
2046	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2047		t.Errorf("wrong response %q, want %q)", got, want)
2048	}
2049}
2050
2051func TestNotificationChannelServiceGetNotificationChannelError(t *testing.T) {
2052	errCode := codes.PermissionDenied
2053	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2054
2055	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2056	var request = &monitoringpb.GetNotificationChannelRequest{
2057		Name: formattedName,
2058	}
2059
2060	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2061	if err != nil {
2062		t.Fatal(err)
2063	}
2064
2065	resp, err := c.GetNotificationChannel(context.Background(), request)
2066
2067	if st, ok := gstatus.FromError(err); !ok {
2068		t.Errorf("got error %v, expected grpc error", err)
2069	} else if c := st.Code(); c != errCode {
2070		t.Errorf("got error code %q, want %q", c, errCode)
2071	}
2072	_ = resp
2073}
2074func TestNotificationChannelServiceCreateNotificationChannel(t *testing.T) {
2075	var type_ string = "type3575610"
2076	var name2 string = "name2-1052831874"
2077	var displayName string = "displayName1615086568"
2078	var description string = "description-1724546052"
2079	var expectedResponse = &monitoringpb.NotificationChannel{
2080		Type:        type_,
2081		Name:        name2,
2082		DisplayName: displayName,
2083		Description: description,
2084	}
2085
2086	mockNotificationChannel.err = nil
2087	mockNotificationChannel.reqs = nil
2088
2089	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2090
2091	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2092	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2093	var request = &monitoringpb.CreateNotificationChannelRequest{
2094		Name:                formattedName,
2095		NotificationChannel: notificationChannel,
2096	}
2097
2098	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2099	if err != nil {
2100		t.Fatal(err)
2101	}
2102
2103	resp, err := c.CreateNotificationChannel(context.Background(), request)
2104
2105	if err != nil {
2106		t.Fatal(err)
2107	}
2108
2109	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2110		t.Errorf("wrong request %q, want %q", got, want)
2111	}
2112
2113	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2114		t.Errorf("wrong response %q, want %q)", got, want)
2115	}
2116}
2117
2118func TestNotificationChannelServiceCreateNotificationChannelError(t *testing.T) {
2119	errCode := codes.PermissionDenied
2120	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2121
2122	var formattedName string = fmt.Sprintf("projects/%s", "[PROJECT]")
2123	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2124	var request = &monitoringpb.CreateNotificationChannelRequest{
2125		Name:                formattedName,
2126		NotificationChannel: notificationChannel,
2127	}
2128
2129	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2130	if err != nil {
2131		t.Fatal(err)
2132	}
2133
2134	resp, err := c.CreateNotificationChannel(context.Background(), request)
2135
2136	if st, ok := gstatus.FromError(err); !ok {
2137		t.Errorf("got error %v, expected grpc error", err)
2138	} else if c := st.Code(); c != errCode {
2139		t.Errorf("got error code %q, want %q", c, errCode)
2140	}
2141	_ = resp
2142}
2143func TestNotificationChannelServiceUpdateNotificationChannel(t *testing.T) {
2144	var type_ string = "type3575610"
2145	var name string = "name3373707"
2146	var displayName string = "displayName1615086568"
2147	var description string = "description-1724546052"
2148	var expectedResponse = &monitoringpb.NotificationChannel{
2149		Type:        type_,
2150		Name:        name,
2151		DisplayName: displayName,
2152		Description: description,
2153	}
2154
2155	mockNotificationChannel.err = nil
2156	mockNotificationChannel.reqs = nil
2157
2158	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2159
2160	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2161	var request = &monitoringpb.UpdateNotificationChannelRequest{
2162		NotificationChannel: notificationChannel,
2163	}
2164
2165	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2166	if err != nil {
2167		t.Fatal(err)
2168	}
2169
2170	resp, err := c.UpdateNotificationChannel(context.Background(), request)
2171
2172	if err != nil {
2173		t.Fatal(err)
2174	}
2175
2176	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2177		t.Errorf("wrong request %q, want %q", got, want)
2178	}
2179
2180	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2181		t.Errorf("wrong response %q, want %q)", got, want)
2182	}
2183}
2184
2185func TestNotificationChannelServiceUpdateNotificationChannelError(t *testing.T) {
2186	errCode := codes.PermissionDenied
2187	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2188
2189	var notificationChannel *monitoringpb.NotificationChannel = &monitoringpb.NotificationChannel{}
2190	var request = &monitoringpb.UpdateNotificationChannelRequest{
2191		NotificationChannel: notificationChannel,
2192	}
2193
2194	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2195	if err != nil {
2196		t.Fatal(err)
2197	}
2198
2199	resp, err := c.UpdateNotificationChannel(context.Background(), request)
2200
2201	if st, ok := gstatus.FromError(err); !ok {
2202		t.Errorf("got error %v, expected grpc error", err)
2203	} else if c := st.Code(); c != errCode {
2204		t.Errorf("got error code %q, want %q", c, errCode)
2205	}
2206	_ = resp
2207}
2208func TestNotificationChannelServiceDeleteNotificationChannel(t *testing.T) {
2209	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
2210
2211	mockNotificationChannel.err = nil
2212	mockNotificationChannel.reqs = nil
2213
2214	mockNotificationChannel.resps = append(mockNotificationChannel.resps[:0], expectedResponse)
2215
2216	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2217	var request = &monitoringpb.DeleteNotificationChannelRequest{
2218		Name: formattedName,
2219	}
2220
2221	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2222	if err != nil {
2223		t.Fatal(err)
2224	}
2225
2226	err = c.DeleteNotificationChannel(context.Background(), request)
2227
2228	if err != nil {
2229		t.Fatal(err)
2230	}
2231
2232	if want, got := request, mockNotificationChannel.reqs[0]; !proto.Equal(want, got) {
2233		t.Errorf("wrong request %q, want %q", got, want)
2234	}
2235
2236}
2237
2238func TestNotificationChannelServiceDeleteNotificationChannelError(t *testing.T) {
2239	errCode := codes.PermissionDenied
2240	mockNotificationChannel.err = gstatus.Error(errCode, "test error")
2241
2242	var formattedName string = fmt.Sprintf("projects/%s/notificationChannels/%s", "[PROJECT]", "[NOTIFICATION_CHANNEL]")
2243	var request = &monitoringpb.DeleteNotificationChannelRequest{
2244		Name: formattedName,
2245	}
2246
2247	c, err := NewNotificationChannelClient(context.Background(), clientOpt)
2248	if err != nil {
2249		t.Fatal(err)
2250	}
2251
2252	err = c.DeleteNotificationChannel(context.Background(), request)
2253
2254	if st, ok := gstatus.FromError(err); !ok {
2255		t.Errorf("got error %v, expected grpc error", err)
2256	} else if c := st.Code(); c != errCode {
2257		t.Errorf("got error code %q, want %q", c, errCode)
2258	}
2259}
2260func TestUptimeCheckServiceListUptimeCheckConfigs(t *testing.T) {
2261	var nextPageToken string = ""
2262	var totalSize int32 = 705419236
2263	var uptimeCheckConfigsElement *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
2264	var uptimeCheckConfigs = []*monitoringpb.UptimeCheckConfig{uptimeCheckConfigsElement}
2265	var expectedResponse = &monitoringpb.ListUptimeCheckConfigsResponse{
2266		NextPageToken:      nextPageToken,
2267		TotalSize:          totalSize,
2268		UptimeCheckConfigs: uptimeCheckConfigs,
2269	}
2270
2271	mockUptimeCheck.err = nil
2272	mockUptimeCheck.reqs = nil
2273
2274	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2275
2276	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2277	var request = &monitoringpb.ListUptimeCheckConfigsRequest{
2278		Parent: formattedParent,
2279	}
2280
2281	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2282	if err != nil {
2283		t.Fatal(err)
2284	}
2285
2286	resp, err := c.ListUptimeCheckConfigs(context.Background(), request).Next()
2287
2288	if err != nil {
2289		t.Fatal(err)
2290	}
2291
2292	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2293		t.Errorf("wrong request %q, want %q", got, want)
2294	}
2295
2296	want := (interface{})(expectedResponse.UptimeCheckConfigs[0])
2297	got := (interface{})(resp)
2298	var ok bool
2299
2300	switch want := (want).(type) {
2301	case proto.Message:
2302		ok = proto.Equal(want, got.(proto.Message))
2303	default:
2304		ok = want == got
2305	}
2306	if !ok {
2307		t.Errorf("wrong response %q, want %q)", got, want)
2308	}
2309}
2310
2311func TestUptimeCheckServiceListUptimeCheckConfigsError(t *testing.T) {
2312	errCode := codes.PermissionDenied
2313	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2314
2315	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2316	var request = &monitoringpb.ListUptimeCheckConfigsRequest{
2317		Parent: formattedParent,
2318	}
2319
2320	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2321	if err != nil {
2322		t.Fatal(err)
2323	}
2324
2325	resp, err := c.ListUptimeCheckConfigs(context.Background(), request).Next()
2326
2327	if st, ok := gstatus.FromError(err); !ok {
2328		t.Errorf("got error %v, expected grpc error", err)
2329	} else if c := st.Code(); c != errCode {
2330		t.Errorf("got error code %q, want %q", c, errCode)
2331	}
2332	_ = resp
2333}
2334func TestUptimeCheckServiceGetUptimeCheckConfig(t *testing.T) {
2335	var name2 string = "name2-1052831874"
2336	var displayName string = "displayName1615086568"
2337	var isInternal bool = true
2338	var expectedResponse = &monitoringpb.UptimeCheckConfig{
2339		Name:        name2,
2340		DisplayName: displayName,
2341		IsInternal:  isInternal,
2342	}
2343
2344	mockUptimeCheck.err = nil
2345	mockUptimeCheck.reqs = nil
2346
2347	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2348
2349	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
2350	var request = &monitoringpb.GetUptimeCheckConfigRequest{
2351		Name: formattedName,
2352	}
2353
2354	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2355	if err != nil {
2356		t.Fatal(err)
2357	}
2358
2359	resp, err := c.GetUptimeCheckConfig(context.Background(), request)
2360
2361	if err != nil {
2362		t.Fatal(err)
2363	}
2364
2365	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2366		t.Errorf("wrong request %q, want %q", got, want)
2367	}
2368
2369	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2370		t.Errorf("wrong response %q, want %q)", got, want)
2371	}
2372}
2373
2374func TestUptimeCheckServiceGetUptimeCheckConfigError(t *testing.T) {
2375	errCode := codes.PermissionDenied
2376	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2377
2378	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
2379	var request = &monitoringpb.GetUptimeCheckConfigRequest{
2380		Name: formattedName,
2381	}
2382
2383	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2384	if err != nil {
2385		t.Fatal(err)
2386	}
2387
2388	resp, err := c.GetUptimeCheckConfig(context.Background(), request)
2389
2390	if st, ok := gstatus.FromError(err); !ok {
2391		t.Errorf("got error %v, expected grpc error", err)
2392	} else if c := st.Code(); c != errCode {
2393		t.Errorf("got error code %q, want %q", c, errCode)
2394	}
2395	_ = resp
2396}
2397func TestUptimeCheckServiceCreateUptimeCheckConfig(t *testing.T) {
2398	var name string = "name3373707"
2399	var displayName string = "displayName1615086568"
2400	var isInternal bool = true
2401	var expectedResponse = &monitoringpb.UptimeCheckConfig{
2402		Name:        name,
2403		DisplayName: displayName,
2404		IsInternal:  isInternal,
2405	}
2406
2407	mockUptimeCheck.err = nil
2408	mockUptimeCheck.reqs = nil
2409
2410	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2411
2412	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2413	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
2414	var request = &monitoringpb.CreateUptimeCheckConfigRequest{
2415		Parent:            formattedParent,
2416		UptimeCheckConfig: uptimeCheckConfig,
2417	}
2418
2419	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2420	if err != nil {
2421		t.Fatal(err)
2422	}
2423
2424	resp, err := c.CreateUptimeCheckConfig(context.Background(), request)
2425
2426	if err != nil {
2427		t.Fatal(err)
2428	}
2429
2430	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2431		t.Errorf("wrong request %q, want %q", got, want)
2432	}
2433
2434	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2435		t.Errorf("wrong response %q, want %q)", got, want)
2436	}
2437}
2438
2439func TestUptimeCheckServiceCreateUptimeCheckConfigError(t *testing.T) {
2440	errCode := codes.PermissionDenied
2441	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2442
2443	var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]")
2444	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
2445	var request = &monitoringpb.CreateUptimeCheckConfigRequest{
2446		Parent:            formattedParent,
2447		UptimeCheckConfig: uptimeCheckConfig,
2448	}
2449
2450	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2451	if err != nil {
2452		t.Fatal(err)
2453	}
2454
2455	resp, err := c.CreateUptimeCheckConfig(context.Background(), request)
2456
2457	if st, ok := gstatus.FromError(err); !ok {
2458		t.Errorf("got error %v, expected grpc error", err)
2459	} else if c := st.Code(); c != errCode {
2460		t.Errorf("got error code %q, want %q", c, errCode)
2461	}
2462	_ = resp
2463}
2464func TestUptimeCheckServiceUpdateUptimeCheckConfig(t *testing.T) {
2465	var name string = "name3373707"
2466	var displayName string = "displayName1615086568"
2467	var isInternal bool = true
2468	var expectedResponse = &monitoringpb.UptimeCheckConfig{
2469		Name:        name,
2470		DisplayName: displayName,
2471		IsInternal:  isInternal,
2472	}
2473
2474	mockUptimeCheck.err = nil
2475	mockUptimeCheck.reqs = nil
2476
2477	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2478
2479	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
2480	var request = &monitoringpb.UpdateUptimeCheckConfigRequest{
2481		UptimeCheckConfig: uptimeCheckConfig,
2482	}
2483
2484	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2485	if err != nil {
2486		t.Fatal(err)
2487	}
2488
2489	resp, err := c.UpdateUptimeCheckConfig(context.Background(), request)
2490
2491	if err != nil {
2492		t.Fatal(err)
2493	}
2494
2495	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2496		t.Errorf("wrong request %q, want %q", got, want)
2497	}
2498
2499	if want, got := expectedResponse, resp; !proto.Equal(want, got) {
2500		t.Errorf("wrong response %q, want %q)", got, want)
2501	}
2502}
2503
2504func TestUptimeCheckServiceUpdateUptimeCheckConfigError(t *testing.T) {
2505	errCode := codes.PermissionDenied
2506	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2507
2508	var uptimeCheckConfig *monitoringpb.UptimeCheckConfig = &monitoringpb.UptimeCheckConfig{}
2509	var request = &monitoringpb.UpdateUptimeCheckConfigRequest{
2510		UptimeCheckConfig: uptimeCheckConfig,
2511	}
2512
2513	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2514	if err != nil {
2515		t.Fatal(err)
2516	}
2517
2518	resp, err := c.UpdateUptimeCheckConfig(context.Background(), request)
2519
2520	if st, ok := gstatus.FromError(err); !ok {
2521		t.Errorf("got error %v, expected grpc error", err)
2522	} else if c := st.Code(); c != errCode {
2523		t.Errorf("got error code %q, want %q", c, errCode)
2524	}
2525	_ = resp
2526}
2527func TestUptimeCheckServiceDeleteUptimeCheckConfig(t *testing.T) {
2528	var expectedResponse *emptypb.Empty = &emptypb.Empty{}
2529
2530	mockUptimeCheck.err = nil
2531	mockUptimeCheck.reqs = nil
2532
2533	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2534
2535	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
2536	var request = &monitoringpb.DeleteUptimeCheckConfigRequest{
2537		Name: formattedName,
2538	}
2539
2540	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2541	if err != nil {
2542		t.Fatal(err)
2543	}
2544
2545	err = c.DeleteUptimeCheckConfig(context.Background(), request)
2546
2547	if err != nil {
2548		t.Fatal(err)
2549	}
2550
2551	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2552		t.Errorf("wrong request %q, want %q", got, want)
2553	}
2554
2555}
2556
2557func TestUptimeCheckServiceDeleteUptimeCheckConfigError(t *testing.T) {
2558	errCode := codes.PermissionDenied
2559	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2560
2561	var formattedName string = fmt.Sprintf("projects/%s/uptimeCheckConfigs/%s", "[PROJECT]", "[UPTIME_CHECK_CONFIG]")
2562	var request = &monitoringpb.DeleteUptimeCheckConfigRequest{
2563		Name: formattedName,
2564	}
2565
2566	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2567	if err != nil {
2568		t.Fatal(err)
2569	}
2570
2571	err = c.DeleteUptimeCheckConfig(context.Background(), request)
2572
2573	if st, ok := gstatus.FromError(err); !ok {
2574		t.Errorf("got error %v, expected grpc error", err)
2575	} else if c := st.Code(); c != errCode {
2576		t.Errorf("got error code %q, want %q", c, errCode)
2577	}
2578}
2579func TestUptimeCheckServiceListUptimeCheckIps(t *testing.T) {
2580	var nextPageToken string = ""
2581	var uptimeCheckIpsElement *monitoringpb.UptimeCheckIp = &monitoringpb.UptimeCheckIp{}
2582	var uptimeCheckIps = []*monitoringpb.UptimeCheckIp{uptimeCheckIpsElement}
2583	var expectedResponse = &monitoringpb.ListUptimeCheckIpsResponse{
2584		NextPageToken:  nextPageToken,
2585		UptimeCheckIps: uptimeCheckIps,
2586	}
2587
2588	mockUptimeCheck.err = nil
2589	mockUptimeCheck.reqs = nil
2590
2591	mockUptimeCheck.resps = append(mockUptimeCheck.resps[:0], expectedResponse)
2592
2593	var request *monitoringpb.ListUptimeCheckIpsRequest = &monitoringpb.ListUptimeCheckIpsRequest{}
2594
2595	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2596	if err != nil {
2597		t.Fatal(err)
2598	}
2599
2600	resp, err := c.ListUptimeCheckIps(context.Background(), request).Next()
2601
2602	if err != nil {
2603		t.Fatal(err)
2604	}
2605
2606	if want, got := request, mockUptimeCheck.reqs[0]; !proto.Equal(want, got) {
2607		t.Errorf("wrong request %q, want %q", got, want)
2608	}
2609
2610	want := (interface{})(expectedResponse.UptimeCheckIps[0])
2611	got := (interface{})(resp)
2612	var ok bool
2613
2614	switch want := (want).(type) {
2615	case proto.Message:
2616		ok = proto.Equal(want, got.(proto.Message))
2617	default:
2618		ok = want == got
2619	}
2620	if !ok {
2621		t.Errorf("wrong response %q, want %q)", got, want)
2622	}
2623}
2624
2625func TestUptimeCheckServiceListUptimeCheckIpsError(t *testing.T) {
2626	errCode := codes.PermissionDenied
2627	mockUptimeCheck.err = gstatus.Error(errCode, "test error")
2628
2629	var request *monitoringpb.ListUptimeCheckIpsRequest = &monitoringpb.ListUptimeCheckIpsRequest{}
2630
2631	c, err := NewUptimeCheckClient(context.Background(), clientOpt)
2632	if err != nil {
2633		t.Fatal(err)
2634	}
2635
2636	resp, err := c.ListUptimeCheckIps(context.Background(), request).Next()
2637
2638	if st, ok := gstatus.FromError(err); !ok {
2639		t.Errorf("got error %v, expected grpc error", err)
2640	} else if c := st.Code(); c != errCode {
2641		t.Errorf("got error code %q, want %q", c, errCode)
2642	}
2643	_ = resp
2644}
2645