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