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 logging 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 monitoredrespb "google.golang.org/genproto/googleapis/api/monitoredres" 35 loggingpb "google.golang.org/genproto/googleapis/logging/v2" 36 field_maskpb "google.golang.org/genproto/protobuf/field_mask" 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 mockConfigServer struct { 51 // Embed for forward compatibility. 52 // Tests will keep working if more methods are added 53 // in the future. 54 loggingpb.ConfigServiceV2Server 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 *mockConfigServer) ListSinks(ctx context.Context, req *loggingpb.ListSinksRequest) (*loggingpb.ListSinksResponse, 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].(*loggingpb.ListSinksResponse), nil 75} 76 77func (s *mockConfigServer) GetSink(ctx context.Context, req *loggingpb.GetSinkRequest) (*loggingpb.LogSink, 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].(*loggingpb.LogSink), nil 87} 88 89func (s *mockConfigServer) CreateSink(ctx context.Context, req *loggingpb.CreateSinkRequest) (*loggingpb.LogSink, 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].(*loggingpb.LogSink), nil 99} 100 101func (s *mockConfigServer) UpdateSink(ctx context.Context, req *loggingpb.UpdateSinkRequest) (*loggingpb.LogSink, 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].(*loggingpb.LogSink), nil 111} 112 113func (s *mockConfigServer) DeleteSink(ctx context.Context, req *loggingpb.DeleteSinkRequest) (*emptypb.Empty, 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].(*emptypb.Empty), nil 123} 124 125func (s *mockConfigServer) ListExclusions(ctx context.Context, req *loggingpb.ListExclusionsRequest) (*loggingpb.ListExclusionsResponse, error) { 126 md, _ := metadata.FromIncomingContext(ctx) 127 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 128 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 129 } 130 s.reqs = append(s.reqs, req) 131 if s.err != nil { 132 return nil, s.err 133 } 134 return s.resps[0].(*loggingpb.ListExclusionsResponse), nil 135} 136 137func (s *mockConfigServer) GetExclusion(ctx context.Context, req *loggingpb.GetExclusionRequest) (*loggingpb.LogExclusion, error) { 138 md, _ := metadata.FromIncomingContext(ctx) 139 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 140 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 141 } 142 s.reqs = append(s.reqs, req) 143 if s.err != nil { 144 return nil, s.err 145 } 146 return s.resps[0].(*loggingpb.LogExclusion), nil 147} 148 149func (s *mockConfigServer) CreateExclusion(ctx context.Context, req *loggingpb.CreateExclusionRequest) (*loggingpb.LogExclusion, error) { 150 md, _ := metadata.FromIncomingContext(ctx) 151 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 152 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 153 } 154 s.reqs = append(s.reqs, req) 155 if s.err != nil { 156 return nil, s.err 157 } 158 return s.resps[0].(*loggingpb.LogExclusion), nil 159} 160 161func (s *mockConfigServer) UpdateExclusion(ctx context.Context, req *loggingpb.UpdateExclusionRequest) (*loggingpb.LogExclusion, error) { 162 md, _ := metadata.FromIncomingContext(ctx) 163 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 164 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 165 } 166 s.reqs = append(s.reqs, req) 167 if s.err != nil { 168 return nil, s.err 169 } 170 return s.resps[0].(*loggingpb.LogExclusion), nil 171} 172 173func (s *mockConfigServer) DeleteExclusion(ctx context.Context, req *loggingpb.DeleteExclusionRequest) (*emptypb.Empty, error) { 174 md, _ := metadata.FromIncomingContext(ctx) 175 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 176 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 177 } 178 s.reqs = append(s.reqs, req) 179 if s.err != nil { 180 return nil, s.err 181 } 182 return s.resps[0].(*emptypb.Empty), nil 183} 184 185func (s *mockConfigServer) GetCmekSettings(ctx context.Context, req *loggingpb.GetCmekSettingsRequest) (*loggingpb.CmekSettings, error) { 186 md, _ := metadata.FromIncomingContext(ctx) 187 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 188 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 189 } 190 s.reqs = append(s.reqs, req) 191 if s.err != nil { 192 return nil, s.err 193 } 194 return s.resps[0].(*loggingpb.CmekSettings), nil 195} 196 197func (s *mockConfigServer) UpdateCmekSettings(ctx context.Context, req *loggingpb.UpdateCmekSettingsRequest) (*loggingpb.CmekSettings, error) { 198 md, _ := metadata.FromIncomingContext(ctx) 199 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 200 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 201 } 202 s.reqs = append(s.reqs, req) 203 if s.err != nil { 204 return nil, s.err 205 } 206 return s.resps[0].(*loggingpb.CmekSettings), nil 207} 208 209type mockLoggingServer struct { 210 // Embed for forward compatibility. 211 // Tests will keep working if more methods are added 212 // in the future. 213 loggingpb.LoggingServiceV2Server 214 215 reqs []proto.Message 216 217 // If set, all calls return this error. 218 err error 219 220 // responses to return if err == nil 221 resps []proto.Message 222} 223 224func (s *mockLoggingServer) DeleteLog(ctx context.Context, req *loggingpb.DeleteLogRequest) (*emptypb.Empty, error) { 225 md, _ := metadata.FromIncomingContext(ctx) 226 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 227 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 228 } 229 s.reqs = append(s.reqs, req) 230 if s.err != nil { 231 return nil, s.err 232 } 233 return s.resps[0].(*emptypb.Empty), nil 234} 235 236func (s *mockLoggingServer) WriteLogEntries(ctx context.Context, req *loggingpb.WriteLogEntriesRequest) (*loggingpb.WriteLogEntriesResponse, error) { 237 md, _ := metadata.FromIncomingContext(ctx) 238 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 239 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 240 } 241 s.reqs = append(s.reqs, req) 242 if s.err != nil { 243 return nil, s.err 244 } 245 return s.resps[0].(*loggingpb.WriteLogEntriesResponse), nil 246} 247 248func (s *mockLoggingServer) ListLogEntries(ctx context.Context, req *loggingpb.ListLogEntriesRequest) (*loggingpb.ListLogEntriesResponse, error) { 249 md, _ := metadata.FromIncomingContext(ctx) 250 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 251 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 252 } 253 s.reqs = append(s.reqs, req) 254 if s.err != nil { 255 return nil, s.err 256 } 257 return s.resps[0].(*loggingpb.ListLogEntriesResponse), nil 258} 259 260func (s *mockLoggingServer) ListMonitoredResourceDescriptors(ctx context.Context, req *loggingpb.ListMonitoredResourceDescriptorsRequest) (*loggingpb.ListMonitoredResourceDescriptorsResponse, error) { 261 md, _ := metadata.FromIncomingContext(ctx) 262 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 263 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 264 } 265 s.reqs = append(s.reqs, req) 266 if s.err != nil { 267 return nil, s.err 268 } 269 return s.resps[0].(*loggingpb.ListMonitoredResourceDescriptorsResponse), nil 270} 271 272func (s *mockLoggingServer) ListLogs(ctx context.Context, req *loggingpb.ListLogsRequest) (*loggingpb.ListLogsResponse, error) { 273 md, _ := metadata.FromIncomingContext(ctx) 274 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 275 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 276 } 277 s.reqs = append(s.reqs, req) 278 if s.err != nil { 279 return nil, s.err 280 } 281 return s.resps[0].(*loggingpb.ListLogsResponse), nil 282} 283 284type mockMetricsServer struct { 285 // Embed for forward compatibility. 286 // Tests will keep working if more methods are added 287 // in the future. 288 loggingpb.MetricsServiceV2Server 289 290 reqs []proto.Message 291 292 // If set, all calls return this error. 293 err error 294 295 // responses to return if err == nil 296 resps []proto.Message 297} 298 299func (s *mockMetricsServer) ListLogMetrics(ctx context.Context, req *loggingpb.ListLogMetricsRequest) (*loggingpb.ListLogMetricsResponse, 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].(*loggingpb.ListLogMetricsResponse), nil 309} 310 311func (s *mockMetricsServer) GetLogMetric(ctx context.Context, req *loggingpb.GetLogMetricRequest) (*loggingpb.LogMetric, 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].(*loggingpb.LogMetric), nil 321} 322 323func (s *mockMetricsServer) CreateLogMetric(ctx context.Context, req *loggingpb.CreateLogMetricRequest) (*loggingpb.LogMetric, error) { 324 md, _ := metadata.FromIncomingContext(ctx) 325 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 326 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 327 } 328 s.reqs = append(s.reqs, req) 329 if s.err != nil { 330 return nil, s.err 331 } 332 return s.resps[0].(*loggingpb.LogMetric), nil 333} 334 335func (s *mockMetricsServer) UpdateLogMetric(ctx context.Context, req *loggingpb.UpdateLogMetricRequest) (*loggingpb.LogMetric, error) { 336 md, _ := metadata.FromIncomingContext(ctx) 337 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 338 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 339 } 340 s.reqs = append(s.reqs, req) 341 if s.err != nil { 342 return nil, s.err 343 } 344 return s.resps[0].(*loggingpb.LogMetric), nil 345} 346 347func (s *mockMetricsServer) DeleteLogMetric(ctx context.Context, req *loggingpb.DeleteLogMetricRequest) (*emptypb.Empty, error) { 348 md, _ := metadata.FromIncomingContext(ctx) 349 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 350 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 351 } 352 s.reqs = append(s.reqs, req) 353 if s.err != nil { 354 return nil, s.err 355 } 356 return s.resps[0].(*emptypb.Empty), nil 357} 358 359// clientOpt is the option tests should use to connect to the test server. 360// It is initialized by TestMain. 361var clientOpt option.ClientOption 362 363var ( 364 mockConfig mockConfigServer 365 mockLogging mockLoggingServer 366 mockMetrics mockMetricsServer 367) 368 369func TestMain(m *testing.M) { 370 flag.Parse() 371 372 serv := grpc.NewServer() 373 loggingpb.RegisterConfigServiceV2Server(serv, &mockConfig) 374 loggingpb.RegisterLoggingServiceV2Server(serv, &mockLogging) 375 loggingpb.RegisterMetricsServiceV2Server(serv, &mockMetrics) 376 377 lis, err := net.Listen("tcp", "localhost:0") 378 if err != nil { 379 log.Fatal(err) 380 } 381 go serv.Serve(lis) 382 383 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 384 if err != nil { 385 log.Fatal(err) 386 } 387 clientOpt = option.WithGRPCConn(conn) 388 389 os.Exit(m.Run()) 390} 391 392func TestConfigServiceV2ListSinks(t *testing.T) { 393 var nextPageToken string = "" 394 var sinksElement *loggingpb.LogSink = &loggingpb.LogSink{} 395 var sinks = []*loggingpb.LogSink{sinksElement} 396 var expectedResponse = &loggingpb.ListSinksResponse{ 397 NextPageToken: nextPageToken, 398 Sinks: sinks, 399 } 400 401 mockConfig.err = nil 402 mockConfig.reqs = nil 403 404 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 405 406 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 407 var request = &loggingpb.ListSinksRequest{ 408 Parent: formattedParent, 409 } 410 411 c, err := NewConfigClient(context.Background(), clientOpt) 412 if err != nil { 413 t.Fatal(err) 414 } 415 416 resp, err := c.ListSinks(context.Background(), request).Next() 417 418 if err != nil { 419 t.Fatal(err) 420 } 421 422 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 423 t.Errorf("wrong request %q, want %q", got, want) 424 } 425 426 want := (interface{})(expectedResponse.Sinks[0]) 427 got := (interface{})(resp) 428 var ok bool 429 430 switch want := (want).(type) { 431 case proto.Message: 432 ok = proto.Equal(want, got.(proto.Message)) 433 default: 434 ok = want == got 435 } 436 if !ok { 437 t.Errorf("wrong response %q, want %q)", got, want) 438 } 439} 440 441func TestConfigServiceV2ListSinksError(t *testing.T) { 442 errCode := codes.PermissionDenied 443 mockConfig.err = gstatus.Error(errCode, "test error") 444 445 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 446 var request = &loggingpb.ListSinksRequest{ 447 Parent: formattedParent, 448 } 449 450 c, err := NewConfigClient(context.Background(), clientOpt) 451 if err != nil { 452 t.Fatal(err) 453 } 454 455 resp, err := c.ListSinks(context.Background(), request).Next() 456 457 if st, ok := gstatus.FromError(err); !ok { 458 t.Errorf("got error %v, expected grpc error", err) 459 } else if c := st.Code(); c != errCode { 460 t.Errorf("got error code %q, want %q", c, errCode) 461 } 462 _ = resp 463} 464func TestConfigServiceV2GetSink(t *testing.T) { 465 var name string = "name3373707" 466 var destination string = "destination-1429847026" 467 var filter string = "filter-1274492040" 468 var description string = "description-1724546052" 469 var disabled bool = true 470 var writerIdentity string = "writerIdentity775638794" 471 var includeChildren bool = true 472 var expectedResponse = &loggingpb.LogSink{ 473 Name: name, 474 Destination: destination, 475 Filter: filter, 476 Description: description, 477 Disabled: disabled, 478 WriterIdentity: writerIdentity, 479 IncludeChildren: includeChildren, 480 } 481 482 mockConfig.err = nil 483 mockConfig.reqs = nil 484 485 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 486 487 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 488 var request = &loggingpb.GetSinkRequest{ 489 SinkName: formattedSinkName, 490 } 491 492 c, err := NewConfigClient(context.Background(), clientOpt) 493 if err != nil { 494 t.Fatal(err) 495 } 496 497 resp, err := c.GetSink(context.Background(), request) 498 499 if err != nil { 500 t.Fatal(err) 501 } 502 503 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 504 t.Errorf("wrong request %q, want %q", got, want) 505 } 506 507 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 508 t.Errorf("wrong response %q, want %q)", got, want) 509 } 510} 511 512func TestConfigServiceV2GetSinkError(t *testing.T) { 513 errCode := codes.PermissionDenied 514 mockConfig.err = gstatus.Error(errCode, "test error") 515 516 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 517 var request = &loggingpb.GetSinkRequest{ 518 SinkName: formattedSinkName, 519 } 520 521 c, err := NewConfigClient(context.Background(), clientOpt) 522 if err != nil { 523 t.Fatal(err) 524 } 525 526 resp, err := c.GetSink(context.Background(), request) 527 528 if st, ok := gstatus.FromError(err); !ok { 529 t.Errorf("got error %v, expected grpc error", err) 530 } else if c := st.Code(); c != errCode { 531 t.Errorf("got error code %q, want %q", c, errCode) 532 } 533 _ = resp 534} 535func TestConfigServiceV2CreateSink(t *testing.T) { 536 var name string = "name3373707" 537 var destination string = "destination-1429847026" 538 var filter string = "filter-1274492040" 539 var description string = "description-1724546052" 540 var disabled bool = true 541 var writerIdentity string = "writerIdentity775638794" 542 var includeChildren bool = true 543 var expectedResponse = &loggingpb.LogSink{ 544 Name: name, 545 Destination: destination, 546 Filter: filter, 547 Description: description, 548 Disabled: disabled, 549 WriterIdentity: writerIdentity, 550 IncludeChildren: includeChildren, 551 } 552 553 mockConfig.err = nil 554 mockConfig.reqs = nil 555 556 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 557 558 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 559 var sink *loggingpb.LogSink = &loggingpb.LogSink{} 560 var request = &loggingpb.CreateSinkRequest{ 561 Parent: formattedParent, 562 Sink: sink, 563 } 564 565 c, err := NewConfigClient(context.Background(), clientOpt) 566 if err != nil { 567 t.Fatal(err) 568 } 569 570 resp, err := c.CreateSink(context.Background(), request) 571 572 if err != nil { 573 t.Fatal(err) 574 } 575 576 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 577 t.Errorf("wrong request %q, want %q", got, want) 578 } 579 580 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 581 t.Errorf("wrong response %q, want %q)", got, want) 582 } 583} 584 585func TestConfigServiceV2CreateSinkError(t *testing.T) { 586 errCode := codes.PermissionDenied 587 mockConfig.err = gstatus.Error(errCode, "test error") 588 589 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 590 var sink *loggingpb.LogSink = &loggingpb.LogSink{} 591 var request = &loggingpb.CreateSinkRequest{ 592 Parent: formattedParent, 593 Sink: sink, 594 } 595 596 c, err := NewConfigClient(context.Background(), clientOpt) 597 if err != nil { 598 t.Fatal(err) 599 } 600 601 resp, err := c.CreateSink(context.Background(), request) 602 603 if st, ok := gstatus.FromError(err); !ok { 604 t.Errorf("got error %v, expected grpc error", err) 605 } else if c := st.Code(); c != errCode { 606 t.Errorf("got error code %q, want %q", c, errCode) 607 } 608 _ = resp 609} 610func TestConfigServiceV2UpdateSink(t *testing.T) { 611 var name string = "name3373707" 612 var destination string = "destination-1429847026" 613 var filter string = "filter-1274492040" 614 var description string = "description-1724546052" 615 var disabled bool = true 616 var writerIdentity string = "writerIdentity775638794" 617 var includeChildren bool = true 618 var expectedResponse = &loggingpb.LogSink{ 619 Name: name, 620 Destination: destination, 621 Filter: filter, 622 Description: description, 623 Disabled: disabled, 624 WriterIdentity: writerIdentity, 625 IncludeChildren: includeChildren, 626 } 627 628 mockConfig.err = nil 629 mockConfig.reqs = nil 630 631 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 632 633 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 634 var sink *loggingpb.LogSink = &loggingpb.LogSink{} 635 var request = &loggingpb.UpdateSinkRequest{ 636 SinkName: formattedSinkName, 637 Sink: sink, 638 } 639 640 c, err := NewConfigClient(context.Background(), clientOpt) 641 if err != nil { 642 t.Fatal(err) 643 } 644 645 resp, err := c.UpdateSink(context.Background(), request) 646 647 if err != nil { 648 t.Fatal(err) 649 } 650 651 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 652 t.Errorf("wrong request %q, want %q", got, want) 653 } 654 655 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 656 t.Errorf("wrong response %q, want %q)", got, want) 657 } 658} 659 660func TestConfigServiceV2UpdateSinkError(t *testing.T) { 661 errCode := codes.PermissionDenied 662 mockConfig.err = gstatus.Error(errCode, "test error") 663 664 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 665 var sink *loggingpb.LogSink = &loggingpb.LogSink{} 666 var request = &loggingpb.UpdateSinkRequest{ 667 SinkName: formattedSinkName, 668 Sink: sink, 669 } 670 671 c, err := NewConfigClient(context.Background(), clientOpt) 672 if err != nil { 673 t.Fatal(err) 674 } 675 676 resp, err := c.UpdateSink(context.Background(), request) 677 678 if st, ok := gstatus.FromError(err); !ok { 679 t.Errorf("got error %v, expected grpc error", err) 680 } else if c := st.Code(); c != errCode { 681 t.Errorf("got error code %q, want %q", c, errCode) 682 } 683 _ = resp 684} 685func TestConfigServiceV2DeleteSink(t *testing.T) { 686 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 687 688 mockConfig.err = nil 689 mockConfig.reqs = nil 690 691 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 692 693 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 694 var request = &loggingpb.DeleteSinkRequest{ 695 SinkName: formattedSinkName, 696 } 697 698 c, err := NewConfigClient(context.Background(), clientOpt) 699 if err != nil { 700 t.Fatal(err) 701 } 702 703 err = c.DeleteSink(context.Background(), request) 704 705 if err != nil { 706 t.Fatal(err) 707 } 708 709 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 710 t.Errorf("wrong request %q, want %q", got, want) 711 } 712 713} 714 715func TestConfigServiceV2DeleteSinkError(t *testing.T) { 716 errCode := codes.PermissionDenied 717 mockConfig.err = gstatus.Error(errCode, "test error") 718 719 var formattedSinkName string = fmt.Sprintf("projects/%s/sinks/%s", "[PROJECT]", "[SINK]") 720 var request = &loggingpb.DeleteSinkRequest{ 721 SinkName: formattedSinkName, 722 } 723 724 c, err := NewConfigClient(context.Background(), clientOpt) 725 if err != nil { 726 t.Fatal(err) 727 } 728 729 err = c.DeleteSink(context.Background(), request) 730 731 if st, ok := gstatus.FromError(err); !ok { 732 t.Errorf("got error %v, expected grpc error", err) 733 } else if c := st.Code(); c != errCode { 734 t.Errorf("got error code %q, want %q", c, errCode) 735 } 736} 737func TestConfigServiceV2ListExclusions(t *testing.T) { 738 var nextPageToken string = "" 739 var exclusionsElement *loggingpb.LogExclusion = &loggingpb.LogExclusion{} 740 var exclusions = []*loggingpb.LogExclusion{exclusionsElement} 741 var expectedResponse = &loggingpb.ListExclusionsResponse{ 742 NextPageToken: nextPageToken, 743 Exclusions: exclusions, 744 } 745 746 mockConfig.err = nil 747 mockConfig.reqs = nil 748 749 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 750 751 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 752 var request = &loggingpb.ListExclusionsRequest{ 753 Parent: formattedParent, 754 } 755 756 c, err := NewConfigClient(context.Background(), clientOpt) 757 if err != nil { 758 t.Fatal(err) 759 } 760 761 resp, err := c.ListExclusions(context.Background(), request).Next() 762 763 if err != nil { 764 t.Fatal(err) 765 } 766 767 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 768 t.Errorf("wrong request %q, want %q", got, want) 769 } 770 771 want := (interface{})(expectedResponse.Exclusions[0]) 772 got := (interface{})(resp) 773 var ok bool 774 775 switch want := (want).(type) { 776 case proto.Message: 777 ok = proto.Equal(want, got.(proto.Message)) 778 default: 779 ok = want == got 780 } 781 if !ok { 782 t.Errorf("wrong response %q, want %q)", got, want) 783 } 784} 785 786func TestConfigServiceV2ListExclusionsError(t *testing.T) { 787 errCode := codes.PermissionDenied 788 mockConfig.err = gstatus.Error(errCode, "test error") 789 790 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 791 var request = &loggingpb.ListExclusionsRequest{ 792 Parent: formattedParent, 793 } 794 795 c, err := NewConfigClient(context.Background(), clientOpt) 796 if err != nil { 797 t.Fatal(err) 798 } 799 800 resp, err := c.ListExclusions(context.Background(), request).Next() 801 802 if st, ok := gstatus.FromError(err); !ok { 803 t.Errorf("got error %v, expected grpc error", err) 804 } else if c := st.Code(); c != errCode { 805 t.Errorf("got error code %q, want %q", c, errCode) 806 } 807 _ = resp 808} 809func TestConfigServiceV2GetExclusion(t *testing.T) { 810 var name2 string = "name2-1052831874" 811 var description string = "description-1724546052" 812 var filter string = "filter-1274492040" 813 var disabled bool = true 814 var expectedResponse = &loggingpb.LogExclusion{ 815 Name: name2, 816 Description: description, 817 Filter: filter, 818 Disabled: disabled, 819 } 820 821 mockConfig.err = nil 822 mockConfig.reqs = nil 823 824 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 825 826 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 827 var request = &loggingpb.GetExclusionRequest{ 828 Name: formattedName, 829 } 830 831 c, err := NewConfigClient(context.Background(), clientOpt) 832 if err != nil { 833 t.Fatal(err) 834 } 835 836 resp, err := c.GetExclusion(context.Background(), request) 837 838 if err != nil { 839 t.Fatal(err) 840 } 841 842 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 843 t.Errorf("wrong request %q, want %q", got, want) 844 } 845 846 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 847 t.Errorf("wrong response %q, want %q)", got, want) 848 } 849} 850 851func TestConfigServiceV2GetExclusionError(t *testing.T) { 852 errCode := codes.PermissionDenied 853 mockConfig.err = gstatus.Error(errCode, "test error") 854 855 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 856 var request = &loggingpb.GetExclusionRequest{ 857 Name: formattedName, 858 } 859 860 c, err := NewConfigClient(context.Background(), clientOpt) 861 if err != nil { 862 t.Fatal(err) 863 } 864 865 resp, err := c.GetExclusion(context.Background(), request) 866 867 if st, ok := gstatus.FromError(err); !ok { 868 t.Errorf("got error %v, expected grpc error", err) 869 } else if c := st.Code(); c != errCode { 870 t.Errorf("got error code %q, want %q", c, errCode) 871 } 872 _ = resp 873} 874func TestConfigServiceV2CreateExclusion(t *testing.T) { 875 var name string = "name3373707" 876 var description string = "description-1724546052" 877 var filter string = "filter-1274492040" 878 var disabled bool = true 879 var expectedResponse = &loggingpb.LogExclusion{ 880 Name: name, 881 Description: description, 882 Filter: filter, 883 Disabled: disabled, 884 } 885 886 mockConfig.err = nil 887 mockConfig.reqs = nil 888 889 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 890 891 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 892 var exclusion *loggingpb.LogExclusion = &loggingpb.LogExclusion{} 893 var request = &loggingpb.CreateExclusionRequest{ 894 Parent: formattedParent, 895 Exclusion: exclusion, 896 } 897 898 c, err := NewConfigClient(context.Background(), clientOpt) 899 if err != nil { 900 t.Fatal(err) 901 } 902 903 resp, err := c.CreateExclusion(context.Background(), request) 904 905 if err != nil { 906 t.Fatal(err) 907 } 908 909 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 910 t.Errorf("wrong request %q, want %q", got, want) 911 } 912 913 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 914 t.Errorf("wrong response %q, want %q)", got, want) 915 } 916} 917 918func TestConfigServiceV2CreateExclusionError(t *testing.T) { 919 errCode := codes.PermissionDenied 920 mockConfig.err = gstatus.Error(errCode, "test error") 921 922 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 923 var exclusion *loggingpb.LogExclusion = &loggingpb.LogExclusion{} 924 var request = &loggingpb.CreateExclusionRequest{ 925 Parent: formattedParent, 926 Exclusion: exclusion, 927 } 928 929 c, err := NewConfigClient(context.Background(), clientOpt) 930 if err != nil { 931 t.Fatal(err) 932 } 933 934 resp, err := c.CreateExclusion(context.Background(), request) 935 936 if st, ok := gstatus.FromError(err); !ok { 937 t.Errorf("got error %v, expected grpc error", err) 938 } else if c := st.Code(); c != errCode { 939 t.Errorf("got error code %q, want %q", c, errCode) 940 } 941 _ = resp 942} 943func TestConfigServiceV2UpdateExclusion(t *testing.T) { 944 var name2 string = "name2-1052831874" 945 var description string = "description-1724546052" 946 var filter string = "filter-1274492040" 947 var disabled bool = true 948 var expectedResponse = &loggingpb.LogExclusion{ 949 Name: name2, 950 Description: description, 951 Filter: filter, 952 Disabled: disabled, 953 } 954 955 mockConfig.err = nil 956 mockConfig.reqs = nil 957 958 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 959 960 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 961 var exclusion *loggingpb.LogExclusion = &loggingpb.LogExclusion{} 962 var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{} 963 var request = &loggingpb.UpdateExclusionRequest{ 964 Name: formattedName, 965 Exclusion: exclusion, 966 UpdateMask: updateMask, 967 } 968 969 c, err := NewConfigClient(context.Background(), clientOpt) 970 if err != nil { 971 t.Fatal(err) 972 } 973 974 resp, err := c.UpdateExclusion(context.Background(), request) 975 976 if err != nil { 977 t.Fatal(err) 978 } 979 980 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 981 t.Errorf("wrong request %q, want %q", got, want) 982 } 983 984 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 985 t.Errorf("wrong response %q, want %q)", got, want) 986 } 987} 988 989func TestConfigServiceV2UpdateExclusionError(t *testing.T) { 990 errCode := codes.PermissionDenied 991 mockConfig.err = gstatus.Error(errCode, "test error") 992 993 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 994 var exclusion *loggingpb.LogExclusion = &loggingpb.LogExclusion{} 995 var updateMask *field_maskpb.FieldMask = &field_maskpb.FieldMask{} 996 var request = &loggingpb.UpdateExclusionRequest{ 997 Name: formattedName, 998 Exclusion: exclusion, 999 UpdateMask: updateMask, 1000 } 1001 1002 c, err := NewConfigClient(context.Background(), clientOpt) 1003 if err != nil { 1004 t.Fatal(err) 1005 } 1006 1007 resp, err := c.UpdateExclusion(context.Background(), request) 1008 1009 if st, ok := gstatus.FromError(err); !ok { 1010 t.Errorf("got error %v, expected grpc error", err) 1011 } else if c := st.Code(); c != errCode { 1012 t.Errorf("got error code %q, want %q", c, errCode) 1013 } 1014 _ = resp 1015} 1016func TestConfigServiceV2DeleteExclusion(t *testing.T) { 1017 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1018 1019 mockConfig.err = nil 1020 mockConfig.reqs = nil 1021 1022 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 1023 1024 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 1025 var request = &loggingpb.DeleteExclusionRequest{ 1026 Name: formattedName, 1027 } 1028 1029 c, err := NewConfigClient(context.Background(), clientOpt) 1030 if err != nil { 1031 t.Fatal(err) 1032 } 1033 1034 err = c.DeleteExclusion(context.Background(), request) 1035 1036 if err != nil { 1037 t.Fatal(err) 1038 } 1039 1040 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 1041 t.Errorf("wrong request %q, want %q", got, want) 1042 } 1043 1044} 1045 1046func TestConfigServiceV2DeleteExclusionError(t *testing.T) { 1047 errCode := codes.PermissionDenied 1048 mockConfig.err = gstatus.Error(errCode, "test error") 1049 1050 var formattedName string = fmt.Sprintf("projects/%s/exclusions/%s", "[PROJECT]", "[EXCLUSION]") 1051 var request = &loggingpb.DeleteExclusionRequest{ 1052 Name: formattedName, 1053 } 1054 1055 c, err := NewConfigClient(context.Background(), clientOpt) 1056 if err != nil { 1057 t.Fatal(err) 1058 } 1059 1060 err = c.DeleteExclusion(context.Background(), request) 1061 1062 if st, ok := gstatus.FromError(err); !ok { 1063 t.Errorf("got error %v, expected grpc error", err) 1064 } else if c := st.Code(); c != errCode { 1065 t.Errorf("got error code %q, want %q", c, errCode) 1066 } 1067} 1068func TestConfigServiceV2GetCmekSettings(t *testing.T) { 1069 var name string = "name3373707" 1070 var kmsKeyName string = "kmsKeyName2094986649" 1071 var serviceAccountId string = "serviceAccountId-111486921" 1072 var expectedResponse = &loggingpb.CmekSettings{ 1073 Name: name, 1074 KmsKeyName: kmsKeyName, 1075 ServiceAccountId: serviceAccountId, 1076 } 1077 1078 mockConfig.err = nil 1079 mockConfig.reqs = nil 1080 1081 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 1082 1083 var request *loggingpb.GetCmekSettingsRequest = &loggingpb.GetCmekSettingsRequest{} 1084 1085 c, err := NewConfigClient(context.Background(), clientOpt) 1086 if err != nil { 1087 t.Fatal(err) 1088 } 1089 1090 resp, err := c.GetCmekSettings(context.Background(), request) 1091 1092 if err != nil { 1093 t.Fatal(err) 1094 } 1095 1096 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 1097 t.Errorf("wrong request %q, want %q", got, want) 1098 } 1099 1100 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1101 t.Errorf("wrong response %q, want %q)", got, want) 1102 } 1103} 1104 1105func TestConfigServiceV2GetCmekSettingsError(t *testing.T) { 1106 errCode := codes.PermissionDenied 1107 mockConfig.err = gstatus.Error(errCode, "test error") 1108 1109 var request *loggingpb.GetCmekSettingsRequest = &loggingpb.GetCmekSettingsRequest{} 1110 1111 c, err := NewConfigClient(context.Background(), clientOpt) 1112 if err != nil { 1113 t.Fatal(err) 1114 } 1115 1116 resp, err := c.GetCmekSettings(context.Background(), request) 1117 1118 if st, ok := gstatus.FromError(err); !ok { 1119 t.Errorf("got error %v, expected grpc error", err) 1120 } else if c := st.Code(); c != errCode { 1121 t.Errorf("got error code %q, want %q", c, errCode) 1122 } 1123 _ = resp 1124} 1125func TestConfigServiceV2UpdateCmekSettings(t *testing.T) { 1126 var name string = "name3373707" 1127 var kmsKeyName string = "kmsKeyName2094986649" 1128 var serviceAccountId string = "serviceAccountId-111486921" 1129 var expectedResponse = &loggingpb.CmekSettings{ 1130 Name: name, 1131 KmsKeyName: kmsKeyName, 1132 ServiceAccountId: serviceAccountId, 1133 } 1134 1135 mockConfig.err = nil 1136 mockConfig.reqs = nil 1137 1138 mockConfig.resps = append(mockConfig.resps[:0], expectedResponse) 1139 1140 var request *loggingpb.UpdateCmekSettingsRequest = &loggingpb.UpdateCmekSettingsRequest{} 1141 1142 c, err := NewConfigClient(context.Background(), clientOpt) 1143 if err != nil { 1144 t.Fatal(err) 1145 } 1146 1147 resp, err := c.UpdateCmekSettings(context.Background(), request) 1148 1149 if err != nil { 1150 t.Fatal(err) 1151 } 1152 1153 if want, got := request, mockConfig.reqs[0]; !proto.Equal(want, got) { 1154 t.Errorf("wrong request %q, want %q", got, want) 1155 } 1156 1157 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1158 t.Errorf("wrong response %q, want %q)", got, want) 1159 } 1160} 1161 1162func TestConfigServiceV2UpdateCmekSettingsError(t *testing.T) { 1163 errCode := codes.PermissionDenied 1164 mockConfig.err = gstatus.Error(errCode, "test error") 1165 1166 var request *loggingpb.UpdateCmekSettingsRequest = &loggingpb.UpdateCmekSettingsRequest{} 1167 1168 c, err := NewConfigClient(context.Background(), clientOpt) 1169 if err != nil { 1170 t.Fatal(err) 1171 } 1172 1173 resp, err := c.UpdateCmekSettings(context.Background(), request) 1174 1175 if st, ok := gstatus.FromError(err); !ok { 1176 t.Errorf("got error %v, expected grpc error", err) 1177 } else if c := st.Code(); c != errCode { 1178 t.Errorf("got error code %q, want %q", c, errCode) 1179 } 1180 _ = resp 1181} 1182func TestLoggingServiceV2DeleteLog(t *testing.T) { 1183 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1184 1185 mockLogging.err = nil 1186 mockLogging.reqs = nil 1187 1188 mockLogging.resps = append(mockLogging.resps[:0], expectedResponse) 1189 1190 var formattedLogName string = fmt.Sprintf("projects/%s/logs/%s", "[PROJECT]", "[LOG]") 1191 var request = &loggingpb.DeleteLogRequest{ 1192 LogName: formattedLogName, 1193 } 1194 1195 c, err := NewClient(context.Background(), clientOpt) 1196 if err != nil { 1197 t.Fatal(err) 1198 } 1199 1200 err = c.DeleteLog(context.Background(), request) 1201 1202 if err != nil { 1203 t.Fatal(err) 1204 } 1205 1206 if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) { 1207 t.Errorf("wrong request %q, want %q", got, want) 1208 } 1209 1210} 1211 1212func TestLoggingServiceV2DeleteLogError(t *testing.T) { 1213 errCode := codes.PermissionDenied 1214 mockLogging.err = gstatus.Error(errCode, "test error") 1215 1216 var formattedLogName string = fmt.Sprintf("projects/%s/logs/%s", "[PROJECT]", "[LOG]") 1217 var request = &loggingpb.DeleteLogRequest{ 1218 LogName: formattedLogName, 1219 } 1220 1221 c, err := NewClient(context.Background(), clientOpt) 1222 if err != nil { 1223 t.Fatal(err) 1224 } 1225 1226 err = c.DeleteLog(context.Background(), request) 1227 1228 if st, ok := gstatus.FromError(err); !ok { 1229 t.Errorf("got error %v, expected grpc error", err) 1230 } else if c := st.Code(); c != errCode { 1231 t.Errorf("got error code %q, want %q", c, errCode) 1232 } 1233} 1234func TestLoggingServiceV2WriteLogEntries(t *testing.T) { 1235 var expectedResponse *loggingpb.WriteLogEntriesResponse = &loggingpb.WriteLogEntriesResponse{} 1236 1237 mockLogging.err = nil 1238 mockLogging.reqs = nil 1239 1240 mockLogging.resps = append(mockLogging.resps[:0], expectedResponse) 1241 1242 var entries []*loggingpb.LogEntry = nil 1243 var request = &loggingpb.WriteLogEntriesRequest{ 1244 Entries: entries, 1245 } 1246 1247 c, err := NewClient(context.Background(), clientOpt) 1248 if err != nil { 1249 t.Fatal(err) 1250 } 1251 1252 resp, err := c.WriteLogEntries(context.Background(), request) 1253 1254 if err != nil { 1255 t.Fatal(err) 1256 } 1257 1258 if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) { 1259 t.Errorf("wrong request %q, want %q", got, want) 1260 } 1261 1262 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1263 t.Errorf("wrong response %q, want %q)", got, want) 1264 } 1265} 1266 1267func TestLoggingServiceV2WriteLogEntriesError(t *testing.T) { 1268 errCode := codes.PermissionDenied 1269 mockLogging.err = gstatus.Error(errCode, "test error") 1270 1271 var entries []*loggingpb.LogEntry = nil 1272 var request = &loggingpb.WriteLogEntriesRequest{ 1273 Entries: entries, 1274 } 1275 1276 c, err := NewClient(context.Background(), clientOpt) 1277 if err != nil { 1278 t.Fatal(err) 1279 } 1280 1281 resp, err := c.WriteLogEntries(context.Background(), request) 1282 1283 if st, ok := gstatus.FromError(err); !ok { 1284 t.Errorf("got error %v, expected grpc error", err) 1285 } else if c := st.Code(); c != errCode { 1286 t.Errorf("got error code %q, want %q", c, errCode) 1287 } 1288 _ = resp 1289} 1290func TestLoggingServiceV2ListLogEntries(t *testing.T) { 1291 var nextPageToken string = "" 1292 var entriesElement *loggingpb.LogEntry = &loggingpb.LogEntry{} 1293 var entries = []*loggingpb.LogEntry{entriesElement} 1294 var expectedResponse = &loggingpb.ListLogEntriesResponse{ 1295 NextPageToken: nextPageToken, 1296 Entries: entries, 1297 } 1298 1299 mockLogging.err = nil 1300 mockLogging.reqs = nil 1301 1302 mockLogging.resps = append(mockLogging.resps[:0], expectedResponse) 1303 1304 var formattedResourceNames []string = nil 1305 var request = &loggingpb.ListLogEntriesRequest{ 1306 ResourceNames: formattedResourceNames, 1307 } 1308 1309 c, err := NewClient(context.Background(), clientOpt) 1310 if err != nil { 1311 t.Fatal(err) 1312 } 1313 1314 resp, err := c.ListLogEntries(context.Background(), request).Next() 1315 1316 if err != nil { 1317 t.Fatal(err) 1318 } 1319 1320 if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) { 1321 t.Errorf("wrong request %q, want %q", got, want) 1322 } 1323 1324 want := (interface{})(expectedResponse.Entries[0]) 1325 got := (interface{})(resp) 1326 var ok bool 1327 1328 switch want := (want).(type) { 1329 case proto.Message: 1330 ok = proto.Equal(want, got.(proto.Message)) 1331 default: 1332 ok = want == got 1333 } 1334 if !ok { 1335 t.Errorf("wrong response %q, want %q)", got, want) 1336 } 1337} 1338 1339func TestLoggingServiceV2ListLogEntriesError(t *testing.T) { 1340 errCode := codes.PermissionDenied 1341 mockLogging.err = gstatus.Error(errCode, "test error") 1342 1343 var formattedResourceNames []string = nil 1344 var request = &loggingpb.ListLogEntriesRequest{ 1345 ResourceNames: formattedResourceNames, 1346 } 1347 1348 c, err := NewClient(context.Background(), clientOpt) 1349 if err != nil { 1350 t.Fatal(err) 1351 } 1352 1353 resp, err := c.ListLogEntries(context.Background(), request).Next() 1354 1355 if st, ok := gstatus.FromError(err); !ok { 1356 t.Errorf("got error %v, expected grpc error", err) 1357 } else if c := st.Code(); c != errCode { 1358 t.Errorf("got error code %q, want %q", c, errCode) 1359 } 1360 _ = resp 1361} 1362func TestLoggingServiceV2ListMonitoredResourceDescriptors(t *testing.T) { 1363 var nextPageToken string = "" 1364 var resourceDescriptorsElement *monitoredrespb.MonitoredResourceDescriptor = &monitoredrespb.MonitoredResourceDescriptor{} 1365 var resourceDescriptors = []*monitoredrespb.MonitoredResourceDescriptor{resourceDescriptorsElement} 1366 var expectedResponse = &loggingpb.ListMonitoredResourceDescriptorsResponse{ 1367 NextPageToken: nextPageToken, 1368 ResourceDescriptors: resourceDescriptors, 1369 } 1370 1371 mockLogging.err = nil 1372 mockLogging.reqs = nil 1373 1374 mockLogging.resps = append(mockLogging.resps[:0], expectedResponse) 1375 1376 var request *loggingpb.ListMonitoredResourceDescriptorsRequest = &loggingpb.ListMonitoredResourceDescriptorsRequest{} 1377 1378 c, err := NewClient(context.Background(), clientOpt) 1379 if err != nil { 1380 t.Fatal(err) 1381 } 1382 1383 resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next() 1384 1385 if err != nil { 1386 t.Fatal(err) 1387 } 1388 1389 if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) { 1390 t.Errorf("wrong request %q, want %q", got, want) 1391 } 1392 1393 want := (interface{})(expectedResponse.ResourceDescriptors[0]) 1394 got := (interface{})(resp) 1395 var ok bool 1396 1397 switch want := (want).(type) { 1398 case proto.Message: 1399 ok = proto.Equal(want, got.(proto.Message)) 1400 default: 1401 ok = want == got 1402 } 1403 if !ok { 1404 t.Errorf("wrong response %q, want %q)", got, want) 1405 } 1406} 1407 1408func TestLoggingServiceV2ListMonitoredResourceDescriptorsError(t *testing.T) { 1409 errCode := codes.PermissionDenied 1410 mockLogging.err = gstatus.Error(errCode, "test error") 1411 1412 var request *loggingpb.ListMonitoredResourceDescriptorsRequest = &loggingpb.ListMonitoredResourceDescriptorsRequest{} 1413 1414 c, err := NewClient(context.Background(), clientOpt) 1415 if err != nil { 1416 t.Fatal(err) 1417 } 1418 1419 resp, err := c.ListMonitoredResourceDescriptors(context.Background(), request).Next() 1420 1421 if st, ok := gstatus.FromError(err); !ok { 1422 t.Errorf("got error %v, expected grpc error", err) 1423 } else if c := st.Code(); c != errCode { 1424 t.Errorf("got error code %q, want %q", c, errCode) 1425 } 1426 _ = resp 1427} 1428func TestLoggingServiceV2ListLogs(t *testing.T) { 1429 var nextPageToken string = "" 1430 var logNamesElement string = "logNamesElement-1079688374" 1431 var logNames = []string{logNamesElement} 1432 var expectedResponse = &loggingpb.ListLogsResponse{ 1433 NextPageToken: nextPageToken, 1434 LogNames: logNames, 1435 } 1436 1437 mockLogging.err = nil 1438 mockLogging.reqs = nil 1439 1440 mockLogging.resps = append(mockLogging.resps[:0], expectedResponse) 1441 1442 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1443 var request = &loggingpb.ListLogsRequest{ 1444 Parent: formattedParent, 1445 } 1446 1447 c, err := NewClient(context.Background(), clientOpt) 1448 if err != nil { 1449 t.Fatal(err) 1450 } 1451 1452 resp, err := c.ListLogs(context.Background(), request).Next() 1453 1454 if err != nil { 1455 t.Fatal(err) 1456 } 1457 1458 if want, got := request, mockLogging.reqs[0]; !proto.Equal(want, got) { 1459 t.Errorf("wrong request %q, want %q", got, want) 1460 } 1461 1462 want := (interface{})(expectedResponse.LogNames[0]) 1463 got := (interface{})(resp) 1464 var ok bool 1465 1466 switch want := (want).(type) { 1467 case proto.Message: 1468 ok = proto.Equal(want, got.(proto.Message)) 1469 default: 1470 ok = want == got 1471 } 1472 if !ok { 1473 t.Errorf("wrong response %q, want %q)", got, want) 1474 } 1475} 1476 1477func TestLoggingServiceV2ListLogsError(t *testing.T) { 1478 errCode := codes.PermissionDenied 1479 mockLogging.err = gstatus.Error(errCode, "test error") 1480 1481 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1482 var request = &loggingpb.ListLogsRequest{ 1483 Parent: formattedParent, 1484 } 1485 1486 c, err := NewClient(context.Background(), clientOpt) 1487 if err != nil { 1488 t.Fatal(err) 1489 } 1490 1491 resp, err := c.ListLogs(context.Background(), request).Next() 1492 1493 if st, ok := gstatus.FromError(err); !ok { 1494 t.Errorf("got error %v, expected grpc error", err) 1495 } else if c := st.Code(); c != errCode { 1496 t.Errorf("got error code %q, want %q", c, errCode) 1497 } 1498 _ = resp 1499} 1500func TestMetricsServiceV2ListLogMetrics(t *testing.T) { 1501 var nextPageToken string = "" 1502 var metricsElement *loggingpb.LogMetric = &loggingpb.LogMetric{} 1503 var metrics = []*loggingpb.LogMetric{metricsElement} 1504 var expectedResponse = &loggingpb.ListLogMetricsResponse{ 1505 NextPageToken: nextPageToken, 1506 Metrics: metrics, 1507 } 1508 1509 mockMetrics.err = nil 1510 mockMetrics.reqs = nil 1511 1512 mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse) 1513 1514 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1515 var request = &loggingpb.ListLogMetricsRequest{ 1516 Parent: formattedParent, 1517 } 1518 1519 c, err := NewMetricsClient(context.Background(), clientOpt) 1520 if err != nil { 1521 t.Fatal(err) 1522 } 1523 1524 resp, err := c.ListLogMetrics(context.Background(), request).Next() 1525 1526 if err != nil { 1527 t.Fatal(err) 1528 } 1529 1530 if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) { 1531 t.Errorf("wrong request %q, want %q", got, want) 1532 } 1533 1534 want := (interface{})(expectedResponse.Metrics[0]) 1535 got := (interface{})(resp) 1536 var ok bool 1537 1538 switch want := (want).(type) { 1539 case proto.Message: 1540 ok = proto.Equal(want, got.(proto.Message)) 1541 default: 1542 ok = want == got 1543 } 1544 if !ok { 1545 t.Errorf("wrong response %q, want %q)", got, want) 1546 } 1547} 1548 1549func TestMetricsServiceV2ListLogMetricsError(t *testing.T) { 1550 errCode := codes.PermissionDenied 1551 mockMetrics.err = gstatus.Error(errCode, "test error") 1552 1553 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1554 var request = &loggingpb.ListLogMetricsRequest{ 1555 Parent: formattedParent, 1556 } 1557 1558 c, err := NewMetricsClient(context.Background(), clientOpt) 1559 if err != nil { 1560 t.Fatal(err) 1561 } 1562 1563 resp, err := c.ListLogMetrics(context.Background(), request).Next() 1564 1565 if st, ok := gstatus.FromError(err); !ok { 1566 t.Errorf("got error %v, expected grpc error", err) 1567 } else if c := st.Code(); c != errCode { 1568 t.Errorf("got error code %q, want %q", c, errCode) 1569 } 1570 _ = resp 1571} 1572func TestMetricsServiceV2GetLogMetric(t *testing.T) { 1573 var name string = "name3373707" 1574 var description string = "description-1724546052" 1575 var filter string = "filter-1274492040" 1576 var valueExtractor string = "valueExtractor2047672534" 1577 var expectedResponse = &loggingpb.LogMetric{ 1578 Name: name, 1579 Description: description, 1580 Filter: filter, 1581 ValueExtractor: valueExtractor, 1582 } 1583 1584 mockMetrics.err = nil 1585 mockMetrics.reqs = nil 1586 1587 mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse) 1588 1589 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1590 var request = &loggingpb.GetLogMetricRequest{ 1591 MetricName: formattedMetricName, 1592 } 1593 1594 c, err := NewMetricsClient(context.Background(), clientOpt) 1595 if err != nil { 1596 t.Fatal(err) 1597 } 1598 1599 resp, err := c.GetLogMetric(context.Background(), request) 1600 1601 if err != nil { 1602 t.Fatal(err) 1603 } 1604 1605 if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) { 1606 t.Errorf("wrong request %q, want %q", got, want) 1607 } 1608 1609 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1610 t.Errorf("wrong response %q, want %q)", got, want) 1611 } 1612} 1613 1614func TestMetricsServiceV2GetLogMetricError(t *testing.T) { 1615 errCode := codes.PermissionDenied 1616 mockMetrics.err = gstatus.Error(errCode, "test error") 1617 1618 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1619 var request = &loggingpb.GetLogMetricRequest{ 1620 MetricName: formattedMetricName, 1621 } 1622 1623 c, err := NewMetricsClient(context.Background(), clientOpt) 1624 if err != nil { 1625 t.Fatal(err) 1626 } 1627 1628 resp, err := c.GetLogMetric(context.Background(), request) 1629 1630 if st, ok := gstatus.FromError(err); !ok { 1631 t.Errorf("got error %v, expected grpc error", err) 1632 } else if c := st.Code(); c != errCode { 1633 t.Errorf("got error code %q, want %q", c, errCode) 1634 } 1635 _ = resp 1636} 1637func TestMetricsServiceV2CreateLogMetric(t *testing.T) { 1638 var name string = "name3373707" 1639 var description string = "description-1724546052" 1640 var filter string = "filter-1274492040" 1641 var valueExtractor string = "valueExtractor2047672534" 1642 var expectedResponse = &loggingpb.LogMetric{ 1643 Name: name, 1644 Description: description, 1645 Filter: filter, 1646 ValueExtractor: valueExtractor, 1647 } 1648 1649 mockMetrics.err = nil 1650 mockMetrics.reqs = nil 1651 1652 mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse) 1653 1654 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1655 var metric *loggingpb.LogMetric = &loggingpb.LogMetric{} 1656 var request = &loggingpb.CreateLogMetricRequest{ 1657 Parent: formattedParent, 1658 Metric: metric, 1659 } 1660 1661 c, err := NewMetricsClient(context.Background(), clientOpt) 1662 if err != nil { 1663 t.Fatal(err) 1664 } 1665 1666 resp, err := c.CreateLogMetric(context.Background(), request) 1667 1668 if err != nil { 1669 t.Fatal(err) 1670 } 1671 1672 if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) { 1673 t.Errorf("wrong request %q, want %q", got, want) 1674 } 1675 1676 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1677 t.Errorf("wrong response %q, want %q)", got, want) 1678 } 1679} 1680 1681func TestMetricsServiceV2CreateLogMetricError(t *testing.T) { 1682 errCode := codes.PermissionDenied 1683 mockMetrics.err = gstatus.Error(errCode, "test error") 1684 1685 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1686 var metric *loggingpb.LogMetric = &loggingpb.LogMetric{} 1687 var request = &loggingpb.CreateLogMetricRequest{ 1688 Parent: formattedParent, 1689 Metric: metric, 1690 } 1691 1692 c, err := NewMetricsClient(context.Background(), clientOpt) 1693 if err != nil { 1694 t.Fatal(err) 1695 } 1696 1697 resp, err := c.CreateLogMetric(context.Background(), request) 1698 1699 if st, ok := gstatus.FromError(err); !ok { 1700 t.Errorf("got error %v, expected grpc error", err) 1701 } else if c := st.Code(); c != errCode { 1702 t.Errorf("got error code %q, want %q", c, errCode) 1703 } 1704 _ = resp 1705} 1706func TestMetricsServiceV2UpdateLogMetric(t *testing.T) { 1707 var name string = "name3373707" 1708 var description string = "description-1724546052" 1709 var filter string = "filter-1274492040" 1710 var valueExtractor string = "valueExtractor2047672534" 1711 var expectedResponse = &loggingpb.LogMetric{ 1712 Name: name, 1713 Description: description, 1714 Filter: filter, 1715 ValueExtractor: valueExtractor, 1716 } 1717 1718 mockMetrics.err = nil 1719 mockMetrics.reqs = nil 1720 1721 mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse) 1722 1723 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1724 var metric *loggingpb.LogMetric = &loggingpb.LogMetric{} 1725 var request = &loggingpb.UpdateLogMetricRequest{ 1726 MetricName: formattedMetricName, 1727 Metric: metric, 1728 } 1729 1730 c, err := NewMetricsClient(context.Background(), clientOpt) 1731 if err != nil { 1732 t.Fatal(err) 1733 } 1734 1735 resp, err := c.UpdateLogMetric(context.Background(), request) 1736 1737 if err != nil { 1738 t.Fatal(err) 1739 } 1740 1741 if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) { 1742 t.Errorf("wrong request %q, want %q", got, want) 1743 } 1744 1745 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1746 t.Errorf("wrong response %q, want %q)", got, want) 1747 } 1748} 1749 1750func TestMetricsServiceV2UpdateLogMetricError(t *testing.T) { 1751 errCode := codes.PermissionDenied 1752 mockMetrics.err = gstatus.Error(errCode, "test error") 1753 1754 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1755 var metric *loggingpb.LogMetric = &loggingpb.LogMetric{} 1756 var request = &loggingpb.UpdateLogMetricRequest{ 1757 MetricName: formattedMetricName, 1758 Metric: metric, 1759 } 1760 1761 c, err := NewMetricsClient(context.Background(), clientOpt) 1762 if err != nil { 1763 t.Fatal(err) 1764 } 1765 1766 resp, err := c.UpdateLogMetric(context.Background(), request) 1767 1768 if st, ok := gstatus.FromError(err); !ok { 1769 t.Errorf("got error %v, expected grpc error", err) 1770 } else if c := st.Code(); c != errCode { 1771 t.Errorf("got error code %q, want %q", c, errCode) 1772 } 1773 _ = resp 1774} 1775func TestMetricsServiceV2DeleteLogMetric(t *testing.T) { 1776 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1777 1778 mockMetrics.err = nil 1779 mockMetrics.reqs = nil 1780 1781 mockMetrics.resps = append(mockMetrics.resps[:0], expectedResponse) 1782 1783 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1784 var request = &loggingpb.DeleteLogMetricRequest{ 1785 MetricName: formattedMetricName, 1786 } 1787 1788 c, err := NewMetricsClient(context.Background(), clientOpt) 1789 if err != nil { 1790 t.Fatal(err) 1791 } 1792 1793 err = c.DeleteLogMetric(context.Background(), request) 1794 1795 if err != nil { 1796 t.Fatal(err) 1797 } 1798 1799 if want, got := request, mockMetrics.reqs[0]; !proto.Equal(want, got) { 1800 t.Errorf("wrong request %q, want %q", got, want) 1801 } 1802 1803} 1804 1805func TestMetricsServiceV2DeleteLogMetricError(t *testing.T) { 1806 errCode := codes.PermissionDenied 1807 mockMetrics.err = gstatus.Error(errCode, "test error") 1808 1809 var formattedMetricName string = fmt.Sprintf("projects/%s/metrics/%s", "[PROJECT]", "[METRIC]") 1810 var request = &loggingpb.DeleteLogMetricRequest{ 1811 MetricName: formattedMetricName, 1812 } 1813 1814 c, err := NewMetricsClient(context.Background(), clientOpt) 1815 if err != nil { 1816 t.Fatal(err) 1817 } 1818 1819 err = c.DeleteLogMetric(context.Background(), request) 1820 1821 if st, ok := gstatus.FromError(err); !ok { 1822 t.Errorf("got error %v, expected grpc error", err) 1823 } else if c := st.Code(); c != errCode { 1824 t.Errorf("got error code %q, want %q", c, errCode) 1825 } 1826} 1827