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