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 dlp 18 19import ( 20 emptypb "github.com/golang/protobuf/ptypes/empty" 21 dlppb "google.golang.org/genproto/googleapis/privacy/dlp/v2" 22) 23 24import ( 25 "flag" 26 "fmt" 27 "io" 28 "log" 29 "net" 30 "os" 31 "strings" 32 "testing" 33 34 "github.com/golang/protobuf/proto" 35 "github.com/golang/protobuf/ptypes" 36 "golang.org/x/net/context" 37 "google.golang.org/api/option" 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 gstatus "google.golang.org/grpc/status" 43) 44 45var _ = io.EOF 46var _ = ptypes.MarshalAny 47var _ status.Status 48 49type mockDlpServer struct { 50 // Embed for forward compatibility. 51 // Tests will keep working if more methods are added 52 // in the future. 53 dlppb.DlpServiceServer 54 55 reqs []proto.Message 56 57 // If set, all calls return this error. 58 err error 59 60 // responses to return if err == nil 61 resps []proto.Message 62} 63 64func (s *mockDlpServer) InspectContent(ctx context.Context, req *dlppb.InspectContentRequest) (*dlppb.InspectContentResponse, error) { 65 md, _ := metadata.FromIncomingContext(ctx) 66 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 67 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 68 } 69 s.reqs = append(s.reqs, req) 70 if s.err != nil { 71 return nil, s.err 72 } 73 return s.resps[0].(*dlppb.InspectContentResponse), nil 74} 75 76func (s *mockDlpServer) RedactImage(ctx context.Context, req *dlppb.RedactImageRequest) (*dlppb.RedactImageResponse, error) { 77 md, _ := metadata.FromIncomingContext(ctx) 78 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 79 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 80 } 81 s.reqs = append(s.reqs, req) 82 if s.err != nil { 83 return nil, s.err 84 } 85 return s.resps[0].(*dlppb.RedactImageResponse), nil 86} 87 88func (s *mockDlpServer) DeidentifyContent(ctx context.Context, req *dlppb.DeidentifyContentRequest) (*dlppb.DeidentifyContentResponse, error) { 89 md, _ := metadata.FromIncomingContext(ctx) 90 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 91 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 92 } 93 s.reqs = append(s.reqs, req) 94 if s.err != nil { 95 return nil, s.err 96 } 97 return s.resps[0].(*dlppb.DeidentifyContentResponse), nil 98} 99 100func (s *mockDlpServer) ReidentifyContent(ctx context.Context, req *dlppb.ReidentifyContentRequest) (*dlppb.ReidentifyContentResponse, error) { 101 md, _ := metadata.FromIncomingContext(ctx) 102 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 103 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 104 } 105 s.reqs = append(s.reqs, req) 106 if s.err != nil { 107 return nil, s.err 108 } 109 return s.resps[0].(*dlppb.ReidentifyContentResponse), nil 110} 111 112func (s *mockDlpServer) ListInfoTypes(ctx context.Context, req *dlppb.ListInfoTypesRequest) (*dlppb.ListInfoTypesResponse, error) { 113 md, _ := metadata.FromIncomingContext(ctx) 114 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 115 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 116 } 117 s.reqs = append(s.reqs, req) 118 if s.err != nil { 119 return nil, s.err 120 } 121 return s.resps[0].(*dlppb.ListInfoTypesResponse), nil 122} 123 124func (s *mockDlpServer) CreateInspectTemplate(ctx context.Context, req *dlppb.CreateInspectTemplateRequest) (*dlppb.InspectTemplate, error) { 125 md, _ := metadata.FromIncomingContext(ctx) 126 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 127 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 128 } 129 s.reqs = append(s.reqs, req) 130 if s.err != nil { 131 return nil, s.err 132 } 133 return s.resps[0].(*dlppb.InspectTemplate), nil 134} 135 136func (s *mockDlpServer) UpdateInspectTemplate(ctx context.Context, req *dlppb.UpdateInspectTemplateRequest) (*dlppb.InspectTemplate, error) { 137 md, _ := metadata.FromIncomingContext(ctx) 138 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 139 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 140 } 141 s.reqs = append(s.reqs, req) 142 if s.err != nil { 143 return nil, s.err 144 } 145 return s.resps[0].(*dlppb.InspectTemplate), nil 146} 147 148func (s *mockDlpServer) GetInspectTemplate(ctx context.Context, req *dlppb.GetInspectTemplateRequest) (*dlppb.InspectTemplate, error) { 149 md, _ := metadata.FromIncomingContext(ctx) 150 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 151 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 152 } 153 s.reqs = append(s.reqs, req) 154 if s.err != nil { 155 return nil, s.err 156 } 157 return s.resps[0].(*dlppb.InspectTemplate), nil 158} 159 160func (s *mockDlpServer) ListInspectTemplates(ctx context.Context, req *dlppb.ListInspectTemplatesRequest) (*dlppb.ListInspectTemplatesResponse, error) { 161 md, _ := metadata.FromIncomingContext(ctx) 162 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 163 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 164 } 165 s.reqs = append(s.reqs, req) 166 if s.err != nil { 167 return nil, s.err 168 } 169 return s.resps[0].(*dlppb.ListInspectTemplatesResponse), nil 170} 171 172func (s *mockDlpServer) DeleteInspectTemplate(ctx context.Context, req *dlppb.DeleteInspectTemplateRequest) (*emptypb.Empty, error) { 173 md, _ := metadata.FromIncomingContext(ctx) 174 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 175 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 176 } 177 s.reqs = append(s.reqs, req) 178 if s.err != nil { 179 return nil, s.err 180 } 181 return s.resps[0].(*emptypb.Empty), nil 182} 183 184func (s *mockDlpServer) CreateDeidentifyTemplate(ctx context.Context, req *dlppb.CreateDeidentifyTemplateRequest) (*dlppb.DeidentifyTemplate, error) { 185 md, _ := metadata.FromIncomingContext(ctx) 186 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 187 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 188 } 189 s.reqs = append(s.reqs, req) 190 if s.err != nil { 191 return nil, s.err 192 } 193 return s.resps[0].(*dlppb.DeidentifyTemplate), nil 194} 195 196func (s *mockDlpServer) UpdateDeidentifyTemplate(ctx context.Context, req *dlppb.UpdateDeidentifyTemplateRequest) (*dlppb.DeidentifyTemplate, error) { 197 md, _ := metadata.FromIncomingContext(ctx) 198 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 199 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 200 } 201 s.reqs = append(s.reqs, req) 202 if s.err != nil { 203 return nil, s.err 204 } 205 return s.resps[0].(*dlppb.DeidentifyTemplate), nil 206} 207 208func (s *mockDlpServer) GetDeidentifyTemplate(ctx context.Context, req *dlppb.GetDeidentifyTemplateRequest) (*dlppb.DeidentifyTemplate, error) { 209 md, _ := metadata.FromIncomingContext(ctx) 210 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 211 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 212 } 213 s.reqs = append(s.reqs, req) 214 if s.err != nil { 215 return nil, s.err 216 } 217 return s.resps[0].(*dlppb.DeidentifyTemplate), nil 218} 219 220func (s *mockDlpServer) ListDeidentifyTemplates(ctx context.Context, req *dlppb.ListDeidentifyTemplatesRequest) (*dlppb.ListDeidentifyTemplatesResponse, error) { 221 md, _ := metadata.FromIncomingContext(ctx) 222 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 223 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 224 } 225 s.reqs = append(s.reqs, req) 226 if s.err != nil { 227 return nil, s.err 228 } 229 return s.resps[0].(*dlppb.ListDeidentifyTemplatesResponse), nil 230} 231 232func (s *mockDlpServer) DeleteDeidentifyTemplate(ctx context.Context, req *dlppb.DeleteDeidentifyTemplateRequest) (*emptypb.Empty, error) { 233 md, _ := metadata.FromIncomingContext(ctx) 234 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 235 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 236 } 237 s.reqs = append(s.reqs, req) 238 if s.err != nil { 239 return nil, s.err 240 } 241 return s.resps[0].(*emptypb.Empty), nil 242} 243 244func (s *mockDlpServer) CreateJobTrigger(ctx context.Context, req *dlppb.CreateJobTriggerRequest) (*dlppb.JobTrigger, error) { 245 md, _ := metadata.FromIncomingContext(ctx) 246 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 247 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 248 } 249 s.reqs = append(s.reqs, req) 250 if s.err != nil { 251 return nil, s.err 252 } 253 return s.resps[0].(*dlppb.JobTrigger), nil 254} 255 256func (s *mockDlpServer) UpdateJobTrigger(ctx context.Context, req *dlppb.UpdateJobTriggerRequest) (*dlppb.JobTrigger, error) { 257 md, _ := metadata.FromIncomingContext(ctx) 258 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 259 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 260 } 261 s.reqs = append(s.reqs, req) 262 if s.err != nil { 263 return nil, s.err 264 } 265 return s.resps[0].(*dlppb.JobTrigger), nil 266} 267 268func (s *mockDlpServer) GetJobTrigger(ctx context.Context, req *dlppb.GetJobTriggerRequest) (*dlppb.JobTrigger, error) { 269 md, _ := metadata.FromIncomingContext(ctx) 270 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 271 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 272 } 273 s.reqs = append(s.reqs, req) 274 if s.err != nil { 275 return nil, s.err 276 } 277 return s.resps[0].(*dlppb.JobTrigger), nil 278} 279 280func (s *mockDlpServer) ListJobTriggers(ctx context.Context, req *dlppb.ListJobTriggersRequest) (*dlppb.ListJobTriggersResponse, error) { 281 md, _ := metadata.FromIncomingContext(ctx) 282 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 283 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 284 } 285 s.reqs = append(s.reqs, req) 286 if s.err != nil { 287 return nil, s.err 288 } 289 return s.resps[0].(*dlppb.ListJobTriggersResponse), nil 290} 291 292func (s *mockDlpServer) DeleteJobTrigger(ctx context.Context, req *dlppb.DeleteJobTriggerRequest) (*emptypb.Empty, error) { 293 md, _ := metadata.FromIncomingContext(ctx) 294 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 295 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 296 } 297 s.reqs = append(s.reqs, req) 298 if s.err != nil { 299 return nil, s.err 300 } 301 return s.resps[0].(*emptypb.Empty), nil 302} 303 304func (s *mockDlpServer) CreateDlpJob(ctx context.Context, req *dlppb.CreateDlpJobRequest) (*dlppb.DlpJob, error) { 305 md, _ := metadata.FromIncomingContext(ctx) 306 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 307 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 308 } 309 s.reqs = append(s.reqs, req) 310 if s.err != nil { 311 return nil, s.err 312 } 313 return s.resps[0].(*dlppb.DlpJob), nil 314} 315 316func (s *mockDlpServer) ListDlpJobs(ctx context.Context, req *dlppb.ListDlpJobsRequest) (*dlppb.ListDlpJobsResponse, error) { 317 md, _ := metadata.FromIncomingContext(ctx) 318 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 319 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 320 } 321 s.reqs = append(s.reqs, req) 322 if s.err != nil { 323 return nil, s.err 324 } 325 return s.resps[0].(*dlppb.ListDlpJobsResponse), nil 326} 327 328func (s *mockDlpServer) GetDlpJob(ctx context.Context, req *dlppb.GetDlpJobRequest) (*dlppb.DlpJob, error) { 329 md, _ := metadata.FromIncomingContext(ctx) 330 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 331 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 332 } 333 s.reqs = append(s.reqs, req) 334 if s.err != nil { 335 return nil, s.err 336 } 337 return s.resps[0].(*dlppb.DlpJob), nil 338} 339 340func (s *mockDlpServer) DeleteDlpJob(ctx context.Context, req *dlppb.DeleteDlpJobRequest) (*emptypb.Empty, error) { 341 md, _ := metadata.FromIncomingContext(ctx) 342 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 343 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 344 } 345 s.reqs = append(s.reqs, req) 346 if s.err != nil { 347 return nil, s.err 348 } 349 return s.resps[0].(*emptypb.Empty), nil 350} 351 352func (s *mockDlpServer) CancelDlpJob(ctx context.Context, req *dlppb.CancelDlpJobRequest) (*emptypb.Empty, error) { 353 md, _ := metadata.FromIncomingContext(ctx) 354 if xg := md["x-goog-api-client"]; len(xg) == 0 || !strings.Contains(xg[0], "gl-go/") { 355 return nil, fmt.Errorf("x-goog-api-client = %v, expected gl-go key", xg) 356 } 357 s.reqs = append(s.reqs, req) 358 if s.err != nil { 359 return nil, s.err 360 } 361 return s.resps[0].(*emptypb.Empty), nil 362} 363 364// clientOpt is the option tests should use to connect to the test server. 365// It is initialized by TestMain. 366var clientOpt option.ClientOption 367 368var ( 369 mockDlp mockDlpServer 370) 371 372func TestMain(m *testing.M) { 373 flag.Parse() 374 375 serv := grpc.NewServer() 376 dlppb.RegisterDlpServiceServer(serv, &mockDlp) 377 378 lis, err := net.Listen("tcp", "localhost:0") 379 if err != nil { 380 log.Fatal(err) 381 } 382 go serv.Serve(lis) 383 384 conn, err := grpc.Dial(lis.Addr().String(), grpc.WithInsecure()) 385 if err != nil { 386 log.Fatal(err) 387 } 388 clientOpt = option.WithGRPCConn(conn) 389 390 os.Exit(m.Run()) 391} 392 393func TestDlpServiceInspectContent(t *testing.T) { 394 var expectedResponse *dlppb.InspectContentResponse = &dlppb.InspectContentResponse{} 395 396 mockDlp.err = nil 397 mockDlp.reqs = nil 398 399 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 400 401 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 402 var request = &dlppb.InspectContentRequest{ 403 Parent: formattedParent, 404 } 405 406 c, err := NewClient(context.Background(), clientOpt) 407 if err != nil { 408 t.Fatal(err) 409 } 410 411 resp, err := c.InspectContent(context.Background(), request) 412 413 if err != nil { 414 t.Fatal(err) 415 } 416 417 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 418 t.Errorf("wrong request %q, want %q", got, want) 419 } 420 421 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 422 t.Errorf("wrong response %q, want %q)", got, want) 423 } 424} 425 426func TestDlpServiceInspectContentError(t *testing.T) { 427 errCode := codes.PermissionDenied 428 mockDlp.err = gstatus.Error(errCode, "test error") 429 430 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 431 var request = &dlppb.InspectContentRequest{ 432 Parent: formattedParent, 433 } 434 435 c, err := NewClient(context.Background(), clientOpt) 436 if err != nil { 437 t.Fatal(err) 438 } 439 440 resp, err := c.InspectContent(context.Background(), request) 441 442 if st, ok := gstatus.FromError(err); !ok { 443 t.Errorf("got error %v, expected grpc error", err) 444 } else if c := st.Code(); c != errCode { 445 t.Errorf("got error code %q, want %q", c, errCode) 446 } 447 _ = resp 448} 449func TestDlpServiceRedactImage(t *testing.T) { 450 var redactedImage []byte = []byte("28") 451 var extractedText string = "extractedText998260012" 452 var expectedResponse = &dlppb.RedactImageResponse{ 453 RedactedImage: redactedImage, 454 ExtractedText: extractedText, 455 } 456 457 mockDlp.err = nil 458 mockDlp.reqs = nil 459 460 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 461 462 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 463 var request = &dlppb.RedactImageRequest{ 464 Parent: formattedParent, 465 } 466 467 c, err := NewClient(context.Background(), clientOpt) 468 if err != nil { 469 t.Fatal(err) 470 } 471 472 resp, err := c.RedactImage(context.Background(), request) 473 474 if err != nil { 475 t.Fatal(err) 476 } 477 478 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 479 t.Errorf("wrong request %q, want %q", got, want) 480 } 481 482 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 483 t.Errorf("wrong response %q, want %q)", got, want) 484 } 485} 486 487func TestDlpServiceRedactImageError(t *testing.T) { 488 errCode := codes.PermissionDenied 489 mockDlp.err = gstatus.Error(errCode, "test error") 490 491 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 492 var request = &dlppb.RedactImageRequest{ 493 Parent: formattedParent, 494 } 495 496 c, err := NewClient(context.Background(), clientOpt) 497 if err != nil { 498 t.Fatal(err) 499 } 500 501 resp, err := c.RedactImage(context.Background(), request) 502 503 if st, ok := gstatus.FromError(err); !ok { 504 t.Errorf("got error %v, expected grpc error", err) 505 } else if c := st.Code(); c != errCode { 506 t.Errorf("got error code %q, want %q", c, errCode) 507 } 508 _ = resp 509} 510func TestDlpServiceDeidentifyContent(t *testing.T) { 511 var expectedResponse *dlppb.DeidentifyContentResponse = &dlppb.DeidentifyContentResponse{} 512 513 mockDlp.err = nil 514 mockDlp.reqs = nil 515 516 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 517 518 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 519 var request = &dlppb.DeidentifyContentRequest{ 520 Parent: formattedParent, 521 } 522 523 c, err := NewClient(context.Background(), clientOpt) 524 if err != nil { 525 t.Fatal(err) 526 } 527 528 resp, err := c.DeidentifyContent(context.Background(), request) 529 530 if err != nil { 531 t.Fatal(err) 532 } 533 534 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 535 t.Errorf("wrong request %q, want %q", got, want) 536 } 537 538 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 539 t.Errorf("wrong response %q, want %q)", got, want) 540 } 541} 542 543func TestDlpServiceDeidentifyContentError(t *testing.T) { 544 errCode := codes.PermissionDenied 545 mockDlp.err = gstatus.Error(errCode, "test error") 546 547 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 548 var request = &dlppb.DeidentifyContentRequest{ 549 Parent: formattedParent, 550 } 551 552 c, err := NewClient(context.Background(), clientOpt) 553 if err != nil { 554 t.Fatal(err) 555 } 556 557 resp, err := c.DeidentifyContent(context.Background(), request) 558 559 if st, ok := gstatus.FromError(err); !ok { 560 t.Errorf("got error %v, expected grpc error", err) 561 } else if c := st.Code(); c != errCode { 562 t.Errorf("got error code %q, want %q", c, errCode) 563 } 564 _ = resp 565} 566func TestDlpServiceReidentifyContent(t *testing.T) { 567 var expectedResponse *dlppb.ReidentifyContentResponse = &dlppb.ReidentifyContentResponse{} 568 569 mockDlp.err = nil 570 mockDlp.reqs = nil 571 572 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 573 574 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 575 var request = &dlppb.ReidentifyContentRequest{ 576 Parent: formattedParent, 577 } 578 579 c, err := NewClient(context.Background(), clientOpt) 580 if err != nil { 581 t.Fatal(err) 582 } 583 584 resp, err := c.ReidentifyContent(context.Background(), request) 585 586 if err != nil { 587 t.Fatal(err) 588 } 589 590 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 591 t.Errorf("wrong request %q, want %q", got, want) 592 } 593 594 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 595 t.Errorf("wrong response %q, want %q)", got, want) 596 } 597} 598 599func TestDlpServiceReidentifyContentError(t *testing.T) { 600 errCode := codes.PermissionDenied 601 mockDlp.err = gstatus.Error(errCode, "test error") 602 603 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 604 var request = &dlppb.ReidentifyContentRequest{ 605 Parent: formattedParent, 606 } 607 608 c, err := NewClient(context.Background(), clientOpt) 609 if err != nil { 610 t.Fatal(err) 611 } 612 613 resp, err := c.ReidentifyContent(context.Background(), request) 614 615 if st, ok := gstatus.FromError(err); !ok { 616 t.Errorf("got error %v, expected grpc error", err) 617 } else if c := st.Code(); c != errCode { 618 t.Errorf("got error code %q, want %q", c, errCode) 619 } 620 _ = resp 621} 622func TestDlpServiceListInfoTypes(t *testing.T) { 623 var expectedResponse *dlppb.ListInfoTypesResponse = &dlppb.ListInfoTypesResponse{} 624 625 mockDlp.err = nil 626 mockDlp.reqs = nil 627 628 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 629 630 var request *dlppb.ListInfoTypesRequest = &dlppb.ListInfoTypesRequest{} 631 632 c, err := NewClient(context.Background(), clientOpt) 633 if err != nil { 634 t.Fatal(err) 635 } 636 637 resp, err := c.ListInfoTypes(context.Background(), request) 638 639 if err != nil { 640 t.Fatal(err) 641 } 642 643 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 644 t.Errorf("wrong request %q, want %q", got, want) 645 } 646 647 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 648 t.Errorf("wrong response %q, want %q)", got, want) 649 } 650} 651 652func TestDlpServiceListInfoTypesError(t *testing.T) { 653 errCode := codes.PermissionDenied 654 mockDlp.err = gstatus.Error(errCode, "test error") 655 656 var request *dlppb.ListInfoTypesRequest = &dlppb.ListInfoTypesRequest{} 657 658 c, err := NewClient(context.Background(), clientOpt) 659 if err != nil { 660 t.Fatal(err) 661 } 662 663 resp, err := c.ListInfoTypes(context.Background(), request) 664 665 if st, ok := gstatus.FromError(err); !ok { 666 t.Errorf("got error %v, expected grpc error", err) 667 } else if c := st.Code(); c != errCode { 668 t.Errorf("got error code %q, want %q", c, errCode) 669 } 670 _ = resp 671} 672func TestDlpServiceCreateInspectTemplate(t *testing.T) { 673 var name string = "name3373707" 674 var displayName string = "displayName1615086568" 675 var description string = "description-1724546052" 676 var expectedResponse = &dlppb.InspectTemplate{ 677 Name: name, 678 DisplayName: displayName, 679 Description: description, 680 } 681 682 mockDlp.err = nil 683 mockDlp.reqs = nil 684 685 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 686 687 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 688 var request = &dlppb.CreateInspectTemplateRequest{ 689 Parent: formattedParent, 690 } 691 692 c, err := NewClient(context.Background(), clientOpt) 693 if err != nil { 694 t.Fatal(err) 695 } 696 697 resp, err := c.CreateInspectTemplate(context.Background(), request) 698 699 if err != nil { 700 t.Fatal(err) 701 } 702 703 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 704 t.Errorf("wrong request %q, want %q", got, want) 705 } 706 707 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 708 t.Errorf("wrong response %q, want %q)", got, want) 709 } 710} 711 712func TestDlpServiceCreateInspectTemplateError(t *testing.T) { 713 errCode := codes.PermissionDenied 714 mockDlp.err = gstatus.Error(errCode, "test error") 715 716 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 717 var request = &dlppb.CreateInspectTemplateRequest{ 718 Parent: formattedParent, 719 } 720 721 c, err := NewClient(context.Background(), clientOpt) 722 if err != nil { 723 t.Fatal(err) 724 } 725 726 resp, err := c.CreateInspectTemplate(context.Background(), request) 727 728 if st, ok := gstatus.FromError(err); !ok { 729 t.Errorf("got error %v, expected grpc error", err) 730 } else if c := st.Code(); c != errCode { 731 t.Errorf("got error code %q, want %q", c, errCode) 732 } 733 _ = resp 734} 735func TestDlpServiceUpdateInspectTemplate(t *testing.T) { 736 var name2 string = "name2-1052831874" 737 var displayName string = "displayName1615086568" 738 var description string = "description-1724546052" 739 var expectedResponse = &dlppb.InspectTemplate{ 740 Name: name2, 741 DisplayName: displayName, 742 Description: description, 743 } 744 745 mockDlp.err = nil 746 mockDlp.reqs = nil 747 748 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 749 750 var formattedName string = fmt.Sprintf("organizations/%s/inspectTemplates/%s", "[ORGANIZATION]", "[INSPECT_TEMPLATE]") 751 var request = &dlppb.UpdateInspectTemplateRequest{ 752 Name: formattedName, 753 } 754 755 c, err := NewClient(context.Background(), clientOpt) 756 if err != nil { 757 t.Fatal(err) 758 } 759 760 resp, err := c.UpdateInspectTemplate(context.Background(), request) 761 762 if err != nil { 763 t.Fatal(err) 764 } 765 766 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 767 t.Errorf("wrong request %q, want %q", got, want) 768 } 769 770 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 771 t.Errorf("wrong response %q, want %q)", got, want) 772 } 773} 774 775func TestDlpServiceUpdateInspectTemplateError(t *testing.T) { 776 errCode := codes.PermissionDenied 777 mockDlp.err = gstatus.Error(errCode, "test error") 778 779 var formattedName string = fmt.Sprintf("organizations/%s/inspectTemplates/%s", "[ORGANIZATION]", "[INSPECT_TEMPLATE]") 780 var request = &dlppb.UpdateInspectTemplateRequest{ 781 Name: formattedName, 782 } 783 784 c, err := NewClient(context.Background(), clientOpt) 785 if err != nil { 786 t.Fatal(err) 787 } 788 789 resp, err := c.UpdateInspectTemplate(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 _ = resp 797} 798func TestDlpServiceGetInspectTemplate(t *testing.T) { 799 var name string = "name3373707" 800 var displayName string = "displayName1615086568" 801 var description string = "description-1724546052" 802 var expectedResponse = &dlppb.InspectTemplate{ 803 Name: name, 804 DisplayName: displayName, 805 Description: description, 806 } 807 808 mockDlp.err = nil 809 mockDlp.reqs = nil 810 811 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 812 813 var request *dlppb.GetInspectTemplateRequest = &dlppb.GetInspectTemplateRequest{} 814 815 c, err := NewClient(context.Background(), clientOpt) 816 if err != nil { 817 t.Fatal(err) 818 } 819 820 resp, err := c.GetInspectTemplate(context.Background(), request) 821 822 if err != nil { 823 t.Fatal(err) 824 } 825 826 if want, got := request, mockDlp.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 TestDlpServiceGetInspectTemplateError(t *testing.T) { 836 errCode := codes.PermissionDenied 837 mockDlp.err = gstatus.Error(errCode, "test error") 838 839 var request *dlppb.GetInspectTemplateRequest = &dlppb.GetInspectTemplateRequest{} 840 841 c, err := NewClient(context.Background(), clientOpt) 842 if err != nil { 843 t.Fatal(err) 844 } 845 846 resp, err := c.GetInspectTemplate(context.Background(), request) 847 848 if st, ok := gstatus.FromError(err); !ok { 849 t.Errorf("got error %v, expected grpc error", err) 850 } else if c := st.Code(); c != errCode { 851 t.Errorf("got error code %q, want %q", c, errCode) 852 } 853 _ = resp 854} 855func TestDlpServiceListInspectTemplates(t *testing.T) { 856 var nextPageToken string = "" 857 var inspectTemplatesElement *dlppb.InspectTemplate = &dlppb.InspectTemplate{} 858 var inspectTemplates = []*dlppb.InspectTemplate{inspectTemplatesElement} 859 var expectedResponse = &dlppb.ListInspectTemplatesResponse{ 860 NextPageToken: nextPageToken, 861 InspectTemplates: inspectTemplates, 862 } 863 864 mockDlp.err = nil 865 mockDlp.reqs = nil 866 867 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 868 869 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 870 var request = &dlppb.ListInspectTemplatesRequest{ 871 Parent: formattedParent, 872 } 873 874 c, err := NewClient(context.Background(), clientOpt) 875 if err != nil { 876 t.Fatal(err) 877 } 878 879 resp, err := c.ListInspectTemplates(context.Background(), request).Next() 880 881 if err != nil { 882 t.Fatal(err) 883 } 884 885 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 886 t.Errorf("wrong request %q, want %q", got, want) 887 } 888 889 want := (interface{})(expectedResponse.InspectTemplates[0]) 890 got := (interface{})(resp) 891 var ok bool 892 893 switch want := (want).(type) { 894 case proto.Message: 895 ok = proto.Equal(want, got.(proto.Message)) 896 default: 897 ok = want == got 898 } 899 if !ok { 900 t.Errorf("wrong response %q, want %q)", got, want) 901 } 902} 903 904func TestDlpServiceListInspectTemplatesError(t *testing.T) { 905 errCode := codes.PermissionDenied 906 mockDlp.err = gstatus.Error(errCode, "test error") 907 908 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 909 var request = &dlppb.ListInspectTemplatesRequest{ 910 Parent: formattedParent, 911 } 912 913 c, err := NewClient(context.Background(), clientOpt) 914 if err != nil { 915 t.Fatal(err) 916 } 917 918 resp, err := c.ListInspectTemplates(context.Background(), request).Next() 919 920 if st, ok := gstatus.FromError(err); !ok { 921 t.Errorf("got error %v, expected grpc error", err) 922 } else if c := st.Code(); c != errCode { 923 t.Errorf("got error code %q, want %q", c, errCode) 924 } 925 _ = resp 926} 927func TestDlpServiceDeleteInspectTemplate(t *testing.T) { 928 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 929 930 mockDlp.err = nil 931 mockDlp.reqs = nil 932 933 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 934 935 var formattedName string = fmt.Sprintf("organizations/%s/inspectTemplates/%s", "[ORGANIZATION]", "[INSPECT_TEMPLATE]") 936 var request = &dlppb.DeleteInspectTemplateRequest{ 937 Name: formattedName, 938 } 939 940 c, err := NewClient(context.Background(), clientOpt) 941 if err != nil { 942 t.Fatal(err) 943 } 944 945 err = c.DeleteInspectTemplate(context.Background(), request) 946 947 if err != nil { 948 t.Fatal(err) 949 } 950 951 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 952 t.Errorf("wrong request %q, want %q", got, want) 953 } 954 955} 956 957func TestDlpServiceDeleteInspectTemplateError(t *testing.T) { 958 errCode := codes.PermissionDenied 959 mockDlp.err = gstatus.Error(errCode, "test error") 960 961 var formattedName string = fmt.Sprintf("organizations/%s/inspectTemplates/%s", "[ORGANIZATION]", "[INSPECT_TEMPLATE]") 962 var request = &dlppb.DeleteInspectTemplateRequest{ 963 Name: formattedName, 964 } 965 966 c, err := NewClient(context.Background(), clientOpt) 967 if err != nil { 968 t.Fatal(err) 969 } 970 971 err = c.DeleteInspectTemplate(context.Background(), request) 972 973 if st, ok := gstatus.FromError(err); !ok { 974 t.Errorf("got error %v, expected grpc error", err) 975 } else if c := st.Code(); c != errCode { 976 t.Errorf("got error code %q, want %q", c, errCode) 977 } 978} 979func TestDlpServiceCreateDeidentifyTemplate(t *testing.T) { 980 var name string = "name3373707" 981 var displayName string = "displayName1615086568" 982 var description string = "description-1724546052" 983 var expectedResponse = &dlppb.DeidentifyTemplate{ 984 Name: name, 985 DisplayName: displayName, 986 Description: description, 987 } 988 989 mockDlp.err = nil 990 mockDlp.reqs = nil 991 992 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 993 994 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 995 var request = &dlppb.CreateDeidentifyTemplateRequest{ 996 Parent: formattedParent, 997 } 998 999 c, err := NewClient(context.Background(), clientOpt) 1000 if err != nil { 1001 t.Fatal(err) 1002 } 1003 1004 resp, err := c.CreateDeidentifyTemplate(context.Background(), request) 1005 1006 if err != nil { 1007 t.Fatal(err) 1008 } 1009 1010 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1011 t.Errorf("wrong request %q, want %q", got, want) 1012 } 1013 1014 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1015 t.Errorf("wrong response %q, want %q)", got, want) 1016 } 1017} 1018 1019func TestDlpServiceCreateDeidentifyTemplateError(t *testing.T) { 1020 errCode := codes.PermissionDenied 1021 mockDlp.err = gstatus.Error(errCode, "test error") 1022 1023 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 1024 var request = &dlppb.CreateDeidentifyTemplateRequest{ 1025 Parent: formattedParent, 1026 } 1027 1028 c, err := NewClient(context.Background(), clientOpt) 1029 if err != nil { 1030 t.Fatal(err) 1031 } 1032 1033 resp, err := c.CreateDeidentifyTemplate(context.Background(), request) 1034 1035 if st, ok := gstatus.FromError(err); !ok { 1036 t.Errorf("got error %v, expected grpc error", err) 1037 } else if c := st.Code(); c != errCode { 1038 t.Errorf("got error code %q, want %q", c, errCode) 1039 } 1040 _ = resp 1041} 1042func TestDlpServiceUpdateDeidentifyTemplate(t *testing.T) { 1043 var name2 string = "name2-1052831874" 1044 var displayName string = "displayName1615086568" 1045 var description string = "description-1724546052" 1046 var expectedResponse = &dlppb.DeidentifyTemplate{ 1047 Name: name2, 1048 DisplayName: displayName, 1049 Description: description, 1050 } 1051 1052 mockDlp.err = nil 1053 mockDlp.reqs = nil 1054 1055 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1056 1057 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1058 var request = &dlppb.UpdateDeidentifyTemplateRequest{ 1059 Name: formattedName, 1060 } 1061 1062 c, err := NewClient(context.Background(), clientOpt) 1063 if err != nil { 1064 t.Fatal(err) 1065 } 1066 1067 resp, err := c.UpdateDeidentifyTemplate(context.Background(), request) 1068 1069 if err != nil { 1070 t.Fatal(err) 1071 } 1072 1073 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1074 t.Errorf("wrong request %q, want %q", got, want) 1075 } 1076 1077 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1078 t.Errorf("wrong response %q, want %q)", got, want) 1079 } 1080} 1081 1082func TestDlpServiceUpdateDeidentifyTemplateError(t *testing.T) { 1083 errCode := codes.PermissionDenied 1084 mockDlp.err = gstatus.Error(errCode, "test error") 1085 1086 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1087 var request = &dlppb.UpdateDeidentifyTemplateRequest{ 1088 Name: formattedName, 1089 } 1090 1091 c, err := NewClient(context.Background(), clientOpt) 1092 if err != nil { 1093 t.Fatal(err) 1094 } 1095 1096 resp, err := c.UpdateDeidentifyTemplate(context.Background(), request) 1097 1098 if st, ok := gstatus.FromError(err); !ok { 1099 t.Errorf("got error %v, expected grpc error", err) 1100 } else if c := st.Code(); c != errCode { 1101 t.Errorf("got error code %q, want %q", c, errCode) 1102 } 1103 _ = resp 1104} 1105func TestDlpServiceGetDeidentifyTemplate(t *testing.T) { 1106 var name2 string = "name2-1052831874" 1107 var displayName string = "displayName1615086568" 1108 var description string = "description-1724546052" 1109 var expectedResponse = &dlppb.DeidentifyTemplate{ 1110 Name: name2, 1111 DisplayName: displayName, 1112 Description: description, 1113 } 1114 1115 mockDlp.err = nil 1116 mockDlp.reqs = nil 1117 1118 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1119 1120 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1121 var request = &dlppb.GetDeidentifyTemplateRequest{ 1122 Name: formattedName, 1123 } 1124 1125 c, err := NewClient(context.Background(), clientOpt) 1126 if err != nil { 1127 t.Fatal(err) 1128 } 1129 1130 resp, err := c.GetDeidentifyTemplate(context.Background(), request) 1131 1132 if err != nil { 1133 t.Fatal(err) 1134 } 1135 1136 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1137 t.Errorf("wrong request %q, want %q", got, want) 1138 } 1139 1140 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1141 t.Errorf("wrong response %q, want %q)", got, want) 1142 } 1143} 1144 1145func TestDlpServiceGetDeidentifyTemplateError(t *testing.T) { 1146 errCode := codes.PermissionDenied 1147 mockDlp.err = gstatus.Error(errCode, "test error") 1148 1149 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1150 var request = &dlppb.GetDeidentifyTemplateRequest{ 1151 Name: formattedName, 1152 } 1153 1154 c, err := NewClient(context.Background(), clientOpt) 1155 if err != nil { 1156 t.Fatal(err) 1157 } 1158 1159 resp, err := c.GetDeidentifyTemplate(context.Background(), request) 1160 1161 if st, ok := gstatus.FromError(err); !ok { 1162 t.Errorf("got error %v, expected grpc error", err) 1163 } else if c := st.Code(); c != errCode { 1164 t.Errorf("got error code %q, want %q", c, errCode) 1165 } 1166 _ = resp 1167} 1168func TestDlpServiceListDeidentifyTemplates(t *testing.T) { 1169 var nextPageToken string = "" 1170 var deidentifyTemplatesElement *dlppb.DeidentifyTemplate = &dlppb.DeidentifyTemplate{} 1171 var deidentifyTemplates = []*dlppb.DeidentifyTemplate{deidentifyTemplatesElement} 1172 var expectedResponse = &dlppb.ListDeidentifyTemplatesResponse{ 1173 NextPageToken: nextPageToken, 1174 DeidentifyTemplates: deidentifyTemplates, 1175 } 1176 1177 mockDlp.err = nil 1178 mockDlp.reqs = nil 1179 1180 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1181 1182 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 1183 var request = &dlppb.ListDeidentifyTemplatesRequest{ 1184 Parent: formattedParent, 1185 } 1186 1187 c, err := NewClient(context.Background(), clientOpt) 1188 if err != nil { 1189 t.Fatal(err) 1190 } 1191 1192 resp, err := c.ListDeidentifyTemplates(context.Background(), request).Next() 1193 1194 if err != nil { 1195 t.Fatal(err) 1196 } 1197 1198 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1199 t.Errorf("wrong request %q, want %q", got, want) 1200 } 1201 1202 want := (interface{})(expectedResponse.DeidentifyTemplates[0]) 1203 got := (interface{})(resp) 1204 var ok bool 1205 1206 switch want := (want).(type) { 1207 case proto.Message: 1208 ok = proto.Equal(want, got.(proto.Message)) 1209 default: 1210 ok = want == got 1211 } 1212 if !ok { 1213 t.Errorf("wrong response %q, want %q)", got, want) 1214 } 1215} 1216 1217func TestDlpServiceListDeidentifyTemplatesError(t *testing.T) { 1218 errCode := codes.PermissionDenied 1219 mockDlp.err = gstatus.Error(errCode, "test error") 1220 1221 var formattedParent string = fmt.Sprintf("organizations/%s", "[ORGANIZATION]") 1222 var request = &dlppb.ListDeidentifyTemplatesRequest{ 1223 Parent: formattedParent, 1224 } 1225 1226 c, err := NewClient(context.Background(), clientOpt) 1227 if err != nil { 1228 t.Fatal(err) 1229 } 1230 1231 resp, err := c.ListDeidentifyTemplates(context.Background(), request).Next() 1232 1233 if st, ok := gstatus.FromError(err); !ok { 1234 t.Errorf("got error %v, expected grpc error", err) 1235 } else if c := st.Code(); c != errCode { 1236 t.Errorf("got error code %q, want %q", c, errCode) 1237 } 1238 _ = resp 1239} 1240func TestDlpServiceDeleteDeidentifyTemplate(t *testing.T) { 1241 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1242 1243 mockDlp.err = nil 1244 mockDlp.reqs = nil 1245 1246 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1247 1248 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1249 var request = &dlppb.DeleteDeidentifyTemplateRequest{ 1250 Name: formattedName, 1251 } 1252 1253 c, err := NewClient(context.Background(), clientOpt) 1254 if err != nil { 1255 t.Fatal(err) 1256 } 1257 1258 err = c.DeleteDeidentifyTemplate(context.Background(), request) 1259 1260 if err != nil { 1261 t.Fatal(err) 1262 } 1263 1264 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1265 t.Errorf("wrong request %q, want %q", got, want) 1266 } 1267 1268} 1269 1270func TestDlpServiceDeleteDeidentifyTemplateError(t *testing.T) { 1271 errCode := codes.PermissionDenied 1272 mockDlp.err = gstatus.Error(errCode, "test error") 1273 1274 var formattedName string = fmt.Sprintf("organizations/%s/deidentifyTemplates/%s", "[ORGANIZATION]", "[DEIDENTIFY_TEMPLATE]") 1275 var request = &dlppb.DeleteDeidentifyTemplateRequest{ 1276 Name: formattedName, 1277 } 1278 1279 c, err := NewClient(context.Background(), clientOpt) 1280 if err != nil { 1281 t.Fatal(err) 1282 } 1283 1284 err = c.DeleteDeidentifyTemplate(context.Background(), request) 1285 1286 if st, ok := gstatus.FromError(err); !ok { 1287 t.Errorf("got error %v, expected grpc error", err) 1288 } else if c := st.Code(); c != errCode { 1289 t.Errorf("got error code %q, want %q", c, errCode) 1290 } 1291} 1292func TestDlpServiceCreateDlpJob(t *testing.T) { 1293 var name string = "name3373707" 1294 var jobTriggerName string = "jobTriggerName1819490804" 1295 var expectedResponse = &dlppb.DlpJob{ 1296 Name: name, 1297 JobTriggerName: jobTriggerName, 1298 } 1299 1300 mockDlp.err = nil 1301 mockDlp.reqs = nil 1302 1303 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1304 1305 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1306 var request = &dlppb.CreateDlpJobRequest{ 1307 Parent: formattedParent, 1308 } 1309 1310 c, err := NewClient(context.Background(), clientOpt) 1311 if err != nil { 1312 t.Fatal(err) 1313 } 1314 1315 resp, err := c.CreateDlpJob(context.Background(), request) 1316 1317 if err != nil { 1318 t.Fatal(err) 1319 } 1320 1321 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1322 t.Errorf("wrong request %q, want %q", got, want) 1323 } 1324 1325 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1326 t.Errorf("wrong response %q, want %q)", got, want) 1327 } 1328} 1329 1330func TestDlpServiceCreateDlpJobError(t *testing.T) { 1331 errCode := codes.PermissionDenied 1332 mockDlp.err = gstatus.Error(errCode, "test error") 1333 1334 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1335 var request = &dlppb.CreateDlpJobRequest{ 1336 Parent: formattedParent, 1337 } 1338 1339 c, err := NewClient(context.Background(), clientOpt) 1340 if err != nil { 1341 t.Fatal(err) 1342 } 1343 1344 resp, err := c.CreateDlpJob(context.Background(), request) 1345 1346 if st, ok := gstatus.FromError(err); !ok { 1347 t.Errorf("got error %v, expected grpc error", err) 1348 } else if c := st.Code(); c != errCode { 1349 t.Errorf("got error code %q, want %q", c, errCode) 1350 } 1351 _ = resp 1352} 1353func TestDlpServiceListDlpJobs(t *testing.T) { 1354 var nextPageToken string = "" 1355 var jobsElement *dlppb.DlpJob = &dlppb.DlpJob{} 1356 var jobs = []*dlppb.DlpJob{jobsElement} 1357 var expectedResponse = &dlppb.ListDlpJobsResponse{ 1358 NextPageToken: nextPageToken, 1359 Jobs: jobs, 1360 } 1361 1362 mockDlp.err = nil 1363 mockDlp.reqs = nil 1364 1365 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1366 1367 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1368 var request = &dlppb.ListDlpJobsRequest{ 1369 Parent: formattedParent, 1370 } 1371 1372 c, err := NewClient(context.Background(), clientOpt) 1373 if err != nil { 1374 t.Fatal(err) 1375 } 1376 1377 resp, err := c.ListDlpJobs(context.Background(), request).Next() 1378 1379 if err != nil { 1380 t.Fatal(err) 1381 } 1382 1383 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1384 t.Errorf("wrong request %q, want %q", got, want) 1385 } 1386 1387 want := (interface{})(expectedResponse.Jobs[0]) 1388 got := (interface{})(resp) 1389 var ok bool 1390 1391 switch want := (want).(type) { 1392 case proto.Message: 1393 ok = proto.Equal(want, got.(proto.Message)) 1394 default: 1395 ok = want == got 1396 } 1397 if !ok { 1398 t.Errorf("wrong response %q, want %q)", got, want) 1399 } 1400} 1401 1402func TestDlpServiceListDlpJobsError(t *testing.T) { 1403 errCode := codes.PermissionDenied 1404 mockDlp.err = gstatus.Error(errCode, "test error") 1405 1406 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1407 var request = &dlppb.ListDlpJobsRequest{ 1408 Parent: formattedParent, 1409 } 1410 1411 c, err := NewClient(context.Background(), clientOpt) 1412 if err != nil { 1413 t.Fatal(err) 1414 } 1415 1416 resp, err := c.ListDlpJobs(context.Background(), request).Next() 1417 1418 if st, ok := gstatus.FromError(err); !ok { 1419 t.Errorf("got error %v, expected grpc error", err) 1420 } else if c := st.Code(); c != errCode { 1421 t.Errorf("got error code %q, want %q", c, errCode) 1422 } 1423 _ = resp 1424} 1425func TestDlpServiceGetDlpJob(t *testing.T) { 1426 var name2 string = "name2-1052831874" 1427 var jobTriggerName string = "jobTriggerName1819490804" 1428 var expectedResponse = &dlppb.DlpJob{ 1429 Name: name2, 1430 JobTriggerName: jobTriggerName, 1431 } 1432 1433 mockDlp.err = nil 1434 mockDlp.reqs = nil 1435 1436 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1437 1438 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1439 var request = &dlppb.GetDlpJobRequest{ 1440 Name: formattedName, 1441 } 1442 1443 c, err := NewClient(context.Background(), clientOpt) 1444 if err != nil { 1445 t.Fatal(err) 1446 } 1447 1448 resp, err := c.GetDlpJob(context.Background(), request) 1449 1450 if err != nil { 1451 t.Fatal(err) 1452 } 1453 1454 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1455 t.Errorf("wrong request %q, want %q", got, want) 1456 } 1457 1458 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1459 t.Errorf("wrong response %q, want %q)", got, want) 1460 } 1461} 1462 1463func TestDlpServiceGetDlpJobError(t *testing.T) { 1464 errCode := codes.PermissionDenied 1465 mockDlp.err = gstatus.Error(errCode, "test error") 1466 1467 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1468 var request = &dlppb.GetDlpJobRequest{ 1469 Name: formattedName, 1470 } 1471 1472 c, err := NewClient(context.Background(), clientOpt) 1473 if err != nil { 1474 t.Fatal(err) 1475 } 1476 1477 resp, err := c.GetDlpJob(context.Background(), request) 1478 1479 if st, ok := gstatus.FromError(err); !ok { 1480 t.Errorf("got error %v, expected grpc error", err) 1481 } else if c := st.Code(); c != errCode { 1482 t.Errorf("got error code %q, want %q", c, errCode) 1483 } 1484 _ = resp 1485} 1486func TestDlpServiceDeleteDlpJob(t *testing.T) { 1487 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1488 1489 mockDlp.err = nil 1490 mockDlp.reqs = nil 1491 1492 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1493 1494 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1495 var request = &dlppb.DeleteDlpJobRequest{ 1496 Name: formattedName, 1497 } 1498 1499 c, err := NewClient(context.Background(), clientOpt) 1500 if err != nil { 1501 t.Fatal(err) 1502 } 1503 1504 err = c.DeleteDlpJob(context.Background(), request) 1505 1506 if err != nil { 1507 t.Fatal(err) 1508 } 1509 1510 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1511 t.Errorf("wrong request %q, want %q", got, want) 1512 } 1513 1514} 1515 1516func TestDlpServiceDeleteDlpJobError(t *testing.T) { 1517 errCode := codes.PermissionDenied 1518 mockDlp.err = gstatus.Error(errCode, "test error") 1519 1520 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1521 var request = &dlppb.DeleteDlpJobRequest{ 1522 Name: formattedName, 1523 } 1524 1525 c, err := NewClient(context.Background(), clientOpt) 1526 if err != nil { 1527 t.Fatal(err) 1528 } 1529 1530 err = c.DeleteDlpJob(context.Background(), request) 1531 1532 if st, ok := gstatus.FromError(err); !ok { 1533 t.Errorf("got error %v, expected grpc error", err) 1534 } else if c := st.Code(); c != errCode { 1535 t.Errorf("got error code %q, want %q", c, errCode) 1536 } 1537} 1538func TestDlpServiceCancelDlpJob(t *testing.T) { 1539 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1540 1541 mockDlp.err = nil 1542 mockDlp.reqs = nil 1543 1544 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1545 1546 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1547 var request = &dlppb.CancelDlpJobRequest{ 1548 Name: formattedName, 1549 } 1550 1551 c, err := NewClient(context.Background(), clientOpt) 1552 if err != nil { 1553 t.Fatal(err) 1554 } 1555 1556 err = c.CancelDlpJob(context.Background(), request) 1557 1558 if err != nil { 1559 t.Fatal(err) 1560 } 1561 1562 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1563 t.Errorf("wrong request %q, want %q", got, want) 1564 } 1565 1566} 1567 1568func TestDlpServiceCancelDlpJobError(t *testing.T) { 1569 errCode := codes.PermissionDenied 1570 mockDlp.err = gstatus.Error(errCode, "test error") 1571 1572 var formattedName string = fmt.Sprintf("projects/%s/dlpJobs/%s", "[PROJECT]", "[DLP_JOB]") 1573 var request = &dlppb.CancelDlpJobRequest{ 1574 Name: formattedName, 1575 } 1576 1577 c, err := NewClient(context.Background(), clientOpt) 1578 if err != nil { 1579 t.Fatal(err) 1580 } 1581 1582 err = c.CancelDlpJob(context.Background(), request) 1583 1584 if st, ok := gstatus.FromError(err); !ok { 1585 t.Errorf("got error %v, expected grpc error", err) 1586 } else if c := st.Code(); c != errCode { 1587 t.Errorf("got error code %q, want %q", c, errCode) 1588 } 1589} 1590func TestDlpServiceListJobTriggers(t *testing.T) { 1591 var nextPageToken string = "" 1592 var jobTriggersElement *dlppb.JobTrigger = &dlppb.JobTrigger{} 1593 var jobTriggers = []*dlppb.JobTrigger{jobTriggersElement} 1594 var expectedResponse = &dlppb.ListJobTriggersResponse{ 1595 NextPageToken: nextPageToken, 1596 JobTriggers: jobTriggers, 1597 } 1598 1599 mockDlp.err = nil 1600 mockDlp.reqs = nil 1601 1602 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1603 1604 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1605 var request = &dlppb.ListJobTriggersRequest{ 1606 Parent: formattedParent, 1607 } 1608 1609 c, err := NewClient(context.Background(), clientOpt) 1610 if err != nil { 1611 t.Fatal(err) 1612 } 1613 1614 resp, err := c.ListJobTriggers(context.Background(), request).Next() 1615 1616 if err != nil { 1617 t.Fatal(err) 1618 } 1619 1620 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1621 t.Errorf("wrong request %q, want %q", got, want) 1622 } 1623 1624 want := (interface{})(expectedResponse.JobTriggers[0]) 1625 got := (interface{})(resp) 1626 var ok bool 1627 1628 switch want := (want).(type) { 1629 case proto.Message: 1630 ok = proto.Equal(want, got.(proto.Message)) 1631 default: 1632 ok = want == got 1633 } 1634 if !ok { 1635 t.Errorf("wrong response %q, want %q)", got, want) 1636 } 1637} 1638 1639func TestDlpServiceListJobTriggersError(t *testing.T) { 1640 errCode := codes.PermissionDenied 1641 mockDlp.err = gstatus.Error(errCode, "test error") 1642 1643 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1644 var request = &dlppb.ListJobTriggersRequest{ 1645 Parent: formattedParent, 1646 } 1647 1648 c, err := NewClient(context.Background(), clientOpt) 1649 if err != nil { 1650 t.Fatal(err) 1651 } 1652 1653 resp, err := c.ListJobTriggers(context.Background(), request).Next() 1654 1655 if st, ok := gstatus.FromError(err); !ok { 1656 t.Errorf("got error %v, expected grpc error", err) 1657 } else if c := st.Code(); c != errCode { 1658 t.Errorf("got error code %q, want %q", c, errCode) 1659 } 1660 _ = resp 1661} 1662func TestDlpServiceGetJobTrigger(t *testing.T) { 1663 var name2 string = "name2-1052831874" 1664 var displayName string = "displayName1615086568" 1665 var description string = "description-1724546052" 1666 var expectedResponse = &dlppb.JobTrigger{ 1667 Name: name2, 1668 DisplayName: displayName, 1669 Description: description, 1670 } 1671 1672 mockDlp.err = nil 1673 mockDlp.reqs = nil 1674 1675 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1676 1677 var formattedName string = fmt.Sprintf("projects/%s/jobTriggers/%s", "[PROJECT]", "[JOB_TRIGGER]") 1678 var request = &dlppb.GetJobTriggerRequest{ 1679 Name: formattedName, 1680 } 1681 1682 c, err := NewClient(context.Background(), clientOpt) 1683 if err != nil { 1684 t.Fatal(err) 1685 } 1686 1687 resp, err := c.GetJobTrigger(context.Background(), request) 1688 1689 if err != nil { 1690 t.Fatal(err) 1691 } 1692 1693 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1694 t.Errorf("wrong request %q, want %q", got, want) 1695 } 1696 1697 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1698 t.Errorf("wrong response %q, want %q)", got, want) 1699 } 1700} 1701 1702func TestDlpServiceGetJobTriggerError(t *testing.T) { 1703 errCode := codes.PermissionDenied 1704 mockDlp.err = gstatus.Error(errCode, "test error") 1705 1706 var formattedName string = fmt.Sprintf("projects/%s/jobTriggers/%s", "[PROJECT]", "[JOB_TRIGGER]") 1707 var request = &dlppb.GetJobTriggerRequest{ 1708 Name: formattedName, 1709 } 1710 1711 c, err := NewClient(context.Background(), clientOpt) 1712 if err != nil { 1713 t.Fatal(err) 1714 } 1715 1716 resp, err := c.GetJobTrigger(context.Background(), request) 1717 1718 if st, ok := gstatus.FromError(err); !ok { 1719 t.Errorf("got error %v, expected grpc error", err) 1720 } else if c := st.Code(); c != errCode { 1721 t.Errorf("got error code %q, want %q", c, errCode) 1722 } 1723 _ = resp 1724} 1725func TestDlpServiceDeleteJobTrigger(t *testing.T) { 1726 var expectedResponse *emptypb.Empty = &emptypb.Empty{} 1727 1728 mockDlp.err = nil 1729 mockDlp.reqs = nil 1730 1731 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1732 1733 var name string = "name3373707" 1734 var request = &dlppb.DeleteJobTriggerRequest{ 1735 Name: name, 1736 } 1737 1738 c, err := NewClient(context.Background(), clientOpt) 1739 if err != nil { 1740 t.Fatal(err) 1741 } 1742 1743 err = c.DeleteJobTrigger(context.Background(), request) 1744 1745 if err != nil { 1746 t.Fatal(err) 1747 } 1748 1749 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1750 t.Errorf("wrong request %q, want %q", got, want) 1751 } 1752 1753} 1754 1755func TestDlpServiceDeleteJobTriggerError(t *testing.T) { 1756 errCode := codes.PermissionDenied 1757 mockDlp.err = gstatus.Error(errCode, "test error") 1758 1759 var name string = "name3373707" 1760 var request = &dlppb.DeleteJobTriggerRequest{ 1761 Name: name, 1762 } 1763 1764 c, err := NewClient(context.Background(), clientOpt) 1765 if err != nil { 1766 t.Fatal(err) 1767 } 1768 1769 err = c.DeleteJobTrigger(context.Background(), request) 1770 1771 if st, ok := gstatus.FromError(err); !ok { 1772 t.Errorf("got error %v, expected grpc error", err) 1773 } else if c := st.Code(); c != errCode { 1774 t.Errorf("got error code %q, want %q", c, errCode) 1775 } 1776} 1777func TestDlpServiceUpdateJobTrigger(t *testing.T) { 1778 var name2 string = "name2-1052831874" 1779 var displayName string = "displayName1615086568" 1780 var description string = "description-1724546052" 1781 var expectedResponse = &dlppb.JobTrigger{ 1782 Name: name2, 1783 DisplayName: displayName, 1784 Description: description, 1785 } 1786 1787 mockDlp.err = nil 1788 mockDlp.reqs = nil 1789 1790 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1791 1792 var formattedName string = fmt.Sprintf("projects/%s/jobTriggers/%s", "[PROJECT]", "[JOB_TRIGGER]") 1793 var request = &dlppb.UpdateJobTriggerRequest{ 1794 Name: formattedName, 1795 } 1796 1797 c, err := NewClient(context.Background(), clientOpt) 1798 if err != nil { 1799 t.Fatal(err) 1800 } 1801 1802 resp, err := c.UpdateJobTrigger(context.Background(), request) 1803 1804 if err != nil { 1805 t.Fatal(err) 1806 } 1807 1808 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1809 t.Errorf("wrong request %q, want %q", got, want) 1810 } 1811 1812 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1813 t.Errorf("wrong response %q, want %q)", got, want) 1814 } 1815} 1816 1817func TestDlpServiceUpdateJobTriggerError(t *testing.T) { 1818 errCode := codes.PermissionDenied 1819 mockDlp.err = gstatus.Error(errCode, "test error") 1820 1821 var formattedName string = fmt.Sprintf("projects/%s/jobTriggers/%s", "[PROJECT]", "[JOB_TRIGGER]") 1822 var request = &dlppb.UpdateJobTriggerRequest{ 1823 Name: formattedName, 1824 } 1825 1826 c, err := NewClient(context.Background(), clientOpt) 1827 if err != nil { 1828 t.Fatal(err) 1829 } 1830 1831 resp, err := c.UpdateJobTrigger(context.Background(), request) 1832 1833 if st, ok := gstatus.FromError(err); !ok { 1834 t.Errorf("got error %v, expected grpc error", err) 1835 } else if c := st.Code(); c != errCode { 1836 t.Errorf("got error code %q, want %q", c, errCode) 1837 } 1838 _ = resp 1839} 1840func TestDlpServiceCreateJobTrigger(t *testing.T) { 1841 var name string = "name3373707" 1842 var displayName string = "displayName1615086568" 1843 var description string = "description-1724546052" 1844 var expectedResponse = &dlppb.JobTrigger{ 1845 Name: name, 1846 DisplayName: displayName, 1847 Description: description, 1848 } 1849 1850 mockDlp.err = nil 1851 mockDlp.reqs = nil 1852 1853 mockDlp.resps = append(mockDlp.resps[:0], expectedResponse) 1854 1855 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1856 var request = &dlppb.CreateJobTriggerRequest{ 1857 Parent: formattedParent, 1858 } 1859 1860 c, err := NewClient(context.Background(), clientOpt) 1861 if err != nil { 1862 t.Fatal(err) 1863 } 1864 1865 resp, err := c.CreateJobTrigger(context.Background(), request) 1866 1867 if err != nil { 1868 t.Fatal(err) 1869 } 1870 1871 if want, got := request, mockDlp.reqs[0]; !proto.Equal(want, got) { 1872 t.Errorf("wrong request %q, want %q", got, want) 1873 } 1874 1875 if want, got := expectedResponse, resp; !proto.Equal(want, got) { 1876 t.Errorf("wrong response %q, want %q)", got, want) 1877 } 1878} 1879 1880func TestDlpServiceCreateJobTriggerError(t *testing.T) { 1881 errCode := codes.PermissionDenied 1882 mockDlp.err = gstatus.Error(errCode, "test error") 1883 1884 var formattedParent string = fmt.Sprintf("projects/%s", "[PROJECT]") 1885 var request = &dlppb.CreateJobTriggerRequest{ 1886 Parent: formattedParent, 1887 } 1888 1889 c, err := NewClient(context.Background(), clientOpt) 1890 if err != nil { 1891 t.Fatal(err) 1892 } 1893 1894 resp, err := c.CreateJobTrigger(context.Background(), request) 1895 1896 if st, ok := gstatus.FromError(err); !ok { 1897 t.Errorf("got error %v, expected grpc error", err) 1898 } else if c := st.Code(); c != errCode { 1899 t.Errorf("got error code %q, want %q", c, errCode) 1900 } 1901 _ = resp 1902} 1903