1 /*
2  * Copyright 2020 Google LLC
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     https://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.google.cloud.devtools.containeranalysis.v1beta1;
17 
18 import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListNoteOccurrencesPagedResponse;
19 import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListNotesPagedResponse;
20 import static com.google.cloud.devtools.containeranalysis.v1beta1.GrafeasV1Beta1Client.ListOccurrencesPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.common.collect.Lists;
30 import com.google.containeranalysis.v1beta1.NoteName;
31 import com.google.containeranalysis.v1beta1.OccurrenceName;
32 import com.google.containeranalysis.v1beta1.ProjectName;
33 import com.google.protobuf.AbstractMessage;
34 import com.google.protobuf.Empty;
35 import com.google.protobuf.FieldMask;
36 import io.grafeas.v1beta1.BatchCreateNotesRequest;
37 import io.grafeas.v1beta1.BatchCreateNotesResponse;
38 import io.grafeas.v1beta1.BatchCreateOccurrencesRequest;
39 import io.grafeas.v1beta1.BatchCreateOccurrencesResponse;
40 import io.grafeas.v1beta1.CreateNoteRequest;
41 import io.grafeas.v1beta1.CreateOccurrenceRequest;
42 import io.grafeas.v1beta1.DeleteNoteRequest;
43 import io.grafeas.v1beta1.DeleteOccurrenceRequest;
44 import io.grafeas.v1beta1.GetNoteRequest;
45 import io.grafeas.v1beta1.GetOccurrenceNoteRequest;
46 import io.grafeas.v1beta1.GetOccurrenceRequest;
47 import io.grafeas.v1beta1.GetVulnerabilityOccurrencesSummaryRequest;
48 import io.grafeas.v1beta1.ListNoteOccurrencesRequest;
49 import io.grafeas.v1beta1.ListNoteOccurrencesResponse;
50 import io.grafeas.v1beta1.ListNotesRequest;
51 import io.grafeas.v1beta1.ListNotesResponse;
52 import io.grafeas.v1beta1.ListOccurrencesRequest;
53 import io.grafeas.v1beta1.ListOccurrencesResponse;
54 import io.grafeas.v1beta1.Note;
55 import io.grafeas.v1beta1.Occurrence;
56 import io.grafeas.v1beta1.UpdateNoteRequest;
57 import io.grafeas.v1beta1.UpdateOccurrenceRequest;
58 import io.grafeas.v1beta1.VulnerabilityOccurrencesSummary;
59 import io.grpc.Status;
60 import io.grpc.StatusRuntimeException;
61 import java.io.IOException;
62 import java.util.ArrayList;
63 import java.util.Arrays;
64 import java.util.HashMap;
65 import java.util.List;
66 import java.util.Map;
67 import java.util.UUID;
68 import org.junit.After;
69 import org.junit.AfterClass;
70 import org.junit.Assert;
71 import org.junit.Before;
72 import org.junit.BeforeClass;
73 import org.junit.Test;
74 
75 @javax.annotation.Generated("by GAPIC")
76 public class GrafeasV1Beta1ClientTest {
77   private static MockContainerAnalysisV1Beta1 mockContainerAnalysisV1Beta1;
78   private static MockGrafeasV1Beta1 mockGrafeasV1Beta1;
79   private static MockServiceHelper serviceHelper;
80   private GrafeasV1Beta1Client client;
81   private LocalChannelProvider channelProvider;
82 
83   @BeforeClass
startStaticServer()84   public static void startStaticServer() {
85     mockContainerAnalysisV1Beta1 = new MockContainerAnalysisV1Beta1();
86     mockGrafeasV1Beta1 = new MockGrafeasV1Beta1();
87     serviceHelper =
88         new MockServiceHelper(
89             UUID.randomUUID().toString(),
90             Arrays.<MockGrpcService>asList(mockContainerAnalysisV1Beta1, mockGrafeasV1Beta1));
91     serviceHelper.start();
92   }
93 
94   @AfterClass
stopServer()95   public static void stopServer() {
96     serviceHelper.stop();
97   }
98 
99   @Before
setUp()100   public void setUp() throws IOException {
101     serviceHelper.reset();
102     channelProvider = serviceHelper.createChannelProvider();
103     GrafeasV1Beta1Settings settings =
104         GrafeasV1Beta1Settings.newBuilder()
105             .setTransportChannelProvider(channelProvider)
106             .setCredentialsProvider(NoCredentialsProvider.create())
107             .build();
108     client = GrafeasV1Beta1Client.create(settings);
109   }
110 
111   @After
tearDown()112   public void tearDown() throws Exception {
113     client.close();
114   }
115 
116   @Test
117   @SuppressWarnings("all")
getOccurrenceTest()118   public void getOccurrenceTest() {
119     String name2 = "name2-1052831874";
120     String noteName = "noteName1780787896";
121     String remediation = "remediation779381797";
122     Occurrence expectedResponse =
123         Occurrence.newBuilder()
124             .setName(name2)
125             .setNoteName(noteName)
126             .setRemediation(remediation)
127             .build();
128     mockGrafeasV1Beta1.addResponse(expectedResponse);
129 
130     OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
131 
132     Occurrence actualResponse = client.getOccurrence(name);
133     Assert.assertEquals(expectedResponse, actualResponse);
134 
135     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
136     Assert.assertEquals(1, actualRequests.size());
137     GetOccurrenceRequest actualRequest = (GetOccurrenceRequest) actualRequests.get(0);
138 
139     Assert.assertEquals(name, OccurrenceName.parse(actualRequest.getName()));
140     Assert.assertTrue(
141         channelProvider.isHeaderSent(
142             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
143             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
144   }
145 
146   @Test
147   @SuppressWarnings("all")
getOccurrenceExceptionTest()148   public void getOccurrenceExceptionTest() throws Exception {
149     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
150     mockGrafeasV1Beta1.addException(exception);
151 
152     try {
153       OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
154 
155       client.getOccurrence(name);
156       Assert.fail("No exception raised");
157     } catch (InvalidArgumentException e) {
158       // Expected exception
159     }
160   }
161 
162   @Test
163   @SuppressWarnings("all")
listOccurrencesTest()164   public void listOccurrencesTest() {
165     String nextPageToken = "";
166     Occurrence occurrencesElement = Occurrence.newBuilder().build();
167     List<Occurrence> occurrences = Arrays.asList(occurrencesElement);
168     ListOccurrencesResponse expectedResponse =
169         ListOccurrencesResponse.newBuilder()
170             .setNextPageToken(nextPageToken)
171             .addAllOccurrences(occurrences)
172             .build();
173     mockGrafeasV1Beta1.addResponse(expectedResponse);
174 
175     ProjectName parent = ProjectName.of("[PROJECT]");
176     String filter = "filter-1274492040";
177 
178     ListOccurrencesPagedResponse pagedListResponse = client.listOccurrences(parent, filter);
179 
180     List<Occurrence> resources = Lists.newArrayList(pagedListResponse.iterateAll());
181     Assert.assertEquals(1, resources.size());
182     Assert.assertEquals(expectedResponse.getOccurrencesList().get(0), resources.get(0));
183 
184     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
185     Assert.assertEquals(1, actualRequests.size());
186     ListOccurrencesRequest actualRequest = (ListOccurrencesRequest) actualRequests.get(0);
187 
188     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
189     Assert.assertEquals(filter, actualRequest.getFilter());
190     Assert.assertTrue(
191         channelProvider.isHeaderSent(
192             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
193             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
194   }
195 
196   @Test
197   @SuppressWarnings("all")
listOccurrencesExceptionTest()198   public void listOccurrencesExceptionTest() throws Exception {
199     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
200     mockGrafeasV1Beta1.addException(exception);
201 
202     try {
203       ProjectName parent = ProjectName.of("[PROJECT]");
204       String filter = "filter-1274492040";
205 
206       client.listOccurrences(parent, filter);
207       Assert.fail("No exception raised");
208     } catch (InvalidArgumentException e) {
209       // Expected exception
210     }
211   }
212 
213   @Test
214   @SuppressWarnings("all")
deleteOccurrenceTest()215   public void deleteOccurrenceTest() {
216     Empty expectedResponse = Empty.newBuilder().build();
217     mockGrafeasV1Beta1.addResponse(expectedResponse);
218 
219     OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
220 
221     client.deleteOccurrence(name);
222 
223     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
224     Assert.assertEquals(1, actualRequests.size());
225     DeleteOccurrenceRequest actualRequest = (DeleteOccurrenceRequest) actualRequests.get(0);
226 
227     Assert.assertEquals(name, OccurrenceName.parse(actualRequest.getName()));
228     Assert.assertTrue(
229         channelProvider.isHeaderSent(
230             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
231             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
232   }
233 
234   @Test
235   @SuppressWarnings("all")
deleteOccurrenceExceptionTest()236   public void deleteOccurrenceExceptionTest() throws Exception {
237     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
238     mockGrafeasV1Beta1.addException(exception);
239 
240     try {
241       OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
242 
243       client.deleteOccurrence(name);
244       Assert.fail("No exception raised");
245     } catch (InvalidArgumentException e) {
246       // Expected exception
247     }
248   }
249 
250   @Test
251   @SuppressWarnings("all")
createOccurrenceTest()252   public void createOccurrenceTest() {
253     String name = "name3373707";
254     String noteName = "noteName1780787896";
255     String remediation = "remediation779381797";
256     Occurrence expectedResponse =
257         Occurrence.newBuilder()
258             .setName(name)
259             .setNoteName(noteName)
260             .setRemediation(remediation)
261             .build();
262     mockGrafeasV1Beta1.addResponse(expectedResponse);
263 
264     ProjectName parent = ProjectName.of("[PROJECT]");
265     Occurrence occurrence = Occurrence.newBuilder().build();
266 
267     Occurrence actualResponse = client.createOccurrence(parent, occurrence);
268     Assert.assertEquals(expectedResponse, actualResponse);
269 
270     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
271     Assert.assertEquals(1, actualRequests.size());
272     CreateOccurrenceRequest actualRequest = (CreateOccurrenceRequest) actualRequests.get(0);
273 
274     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
275     Assert.assertEquals(occurrence, actualRequest.getOccurrence());
276     Assert.assertTrue(
277         channelProvider.isHeaderSent(
278             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
279             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
280   }
281 
282   @Test
283   @SuppressWarnings("all")
createOccurrenceExceptionTest()284   public void createOccurrenceExceptionTest() throws Exception {
285     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
286     mockGrafeasV1Beta1.addException(exception);
287 
288     try {
289       ProjectName parent = ProjectName.of("[PROJECT]");
290       Occurrence occurrence = Occurrence.newBuilder().build();
291 
292       client.createOccurrence(parent, occurrence);
293       Assert.fail("No exception raised");
294     } catch (InvalidArgumentException e) {
295       // Expected exception
296     }
297   }
298 
299   @Test
300   @SuppressWarnings("all")
batchCreateOccurrencesTest()301   public void batchCreateOccurrencesTest() {
302     BatchCreateOccurrencesResponse expectedResponse =
303         BatchCreateOccurrencesResponse.newBuilder().build();
304     mockGrafeasV1Beta1.addResponse(expectedResponse);
305 
306     ProjectName parent = ProjectName.of("[PROJECT]");
307     List<Occurrence> occurrences = new ArrayList<>();
308 
309     BatchCreateOccurrencesResponse actualResponse =
310         client.batchCreateOccurrences(parent, occurrences);
311     Assert.assertEquals(expectedResponse, actualResponse);
312 
313     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
314     Assert.assertEquals(1, actualRequests.size());
315     BatchCreateOccurrencesRequest actualRequest =
316         (BatchCreateOccurrencesRequest) actualRequests.get(0);
317 
318     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
319     Assert.assertEquals(occurrences, actualRequest.getOccurrencesList());
320     Assert.assertTrue(
321         channelProvider.isHeaderSent(
322             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
323             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
324   }
325 
326   @Test
327   @SuppressWarnings("all")
batchCreateOccurrencesExceptionTest()328   public void batchCreateOccurrencesExceptionTest() throws Exception {
329     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
330     mockGrafeasV1Beta1.addException(exception);
331 
332     try {
333       ProjectName parent = ProjectName.of("[PROJECT]");
334       List<Occurrence> occurrences = new ArrayList<>();
335 
336       client.batchCreateOccurrences(parent, occurrences);
337       Assert.fail("No exception raised");
338     } catch (InvalidArgumentException e) {
339       // Expected exception
340     }
341   }
342 
343   @Test
344   @SuppressWarnings("all")
updateOccurrenceTest()345   public void updateOccurrenceTest() {
346     String name2 = "name2-1052831874";
347     String noteName = "noteName1780787896";
348     String remediation = "remediation779381797";
349     Occurrence expectedResponse =
350         Occurrence.newBuilder()
351             .setName(name2)
352             .setNoteName(noteName)
353             .setRemediation(remediation)
354             .build();
355     mockGrafeasV1Beta1.addResponse(expectedResponse);
356 
357     OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
358     Occurrence occurrence = Occurrence.newBuilder().build();
359     FieldMask updateMask = FieldMask.newBuilder().build();
360 
361     Occurrence actualResponse = client.updateOccurrence(name, occurrence, updateMask);
362     Assert.assertEquals(expectedResponse, actualResponse);
363 
364     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
365     Assert.assertEquals(1, actualRequests.size());
366     UpdateOccurrenceRequest actualRequest = (UpdateOccurrenceRequest) actualRequests.get(0);
367 
368     Assert.assertEquals(name, OccurrenceName.parse(actualRequest.getName()));
369     Assert.assertEquals(occurrence, actualRequest.getOccurrence());
370     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
371     Assert.assertTrue(
372         channelProvider.isHeaderSent(
373             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
374             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
375   }
376 
377   @Test
378   @SuppressWarnings("all")
updateOccurrenceExceptionTest()379   public void updateOccurrenceExceptionTest() throws Exception {
380     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
381     mockGrafeasV1Beta1.addException(exception);
382 
383     try {
384       OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
385       Occurrence occurrence = Occurrence.newBuilder().build();
386       FieldMask updateMask = FieldMask.newBuilder().build();
387 
388       client.updateOccurrence(name, occurrence, updateMask);
389       Assert.fail("No exception raised");
390     } catch (InvalidArgumentException e) {
391       // Expected exception
392     }
393   }
394 
395   @Test
396   @SuppressWarnings("all")
getOccurrenceNoteTest()397   public void getOccurrenceNoteTest() {
398     String name2 = "name2-1052831874";
399     String shortDescription = "shortDescription-235369287";
400     String longDescription = "longDescription-1747792199";
401     Note expectedResponse =
402         Note.newBuilder()
403             .setName(name2)
404             .setShortDescription(shortDescription)
405             .setLongDescription(longDescription)
406             .build();
407     mockGrafeasV1Beta1.addResponse(expectedResponse);
408 
409     OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
410 
411     Note actualResponse = client.getOccurrenceNote(name);
412     Assert.assertEquals(expectedResponse, actualResponse);
413 
414     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
415     Assert.assertEquals(1, actualRequests.size());
416     GetOccurrenceNoteRequest actualRequest = (GetOccurrenceNoteRequest) actualRequests.get(0);
417 
418     Assert.assertEquals(name, OccurrenceName.parse(actualRequest.getName()));
419     Assert.assertTrue(
420         channelProvider.isHeaderSent(
421             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
422             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
423   }
424 
425   @Test
426   @SuppressWarnings("all")
getOccurrenceNoteExceptionTest()427   public void getOccurrenceNoteExceptionTest() throws Exception {
428     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
429     mockGrafeasV1Beta1.addException(exception);
430 
431     try {
432       OccurrenceName name = OccurrenceName.of("[PROJECT]", "[OCCURRENCE]");
433 
434       client.getOccurrenceNote(name);
435       Assert.fail("No exception raised");
436     } catch (InvalidArgumentException e) {
437       // Expected exception
438     }
439   }
440 
441   @Test
442   @SuppressWarnings("all")
getNoteTest()443   public void getNoteTest() {
444     String name2 = "name2-1052831874";
445     String shortDescription = "shortDescription-235369287";
446     String longDescription = "longDescription-1747792199";
447     Note expectedResponse =
448         Note.newBuilder()
449             .setName(name2)
450             .setShortDescription(shortDescription)
451             .setLongDescription(longDescription)
452             .build();
453     mockGrafeasV1Beta1.addResponse(expectedResponse);
454 
455     NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
456 
457     Note actualResponse = client.getNote(name);
458     Assert.assertEquals(expectedResponse, actualResponse);
459 
460     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
461     Assert.assertEquals(1, actualRequests.size());
462     GetNoteRequest actualRequest = (GetNoteRequest) actualRequests.get(0);
463 
464     Assert.assertEquals(name, NoteName.parse(actualRequest.getName()));
465     Assert.assertTrue(
466         channelProvider.isHeaderSent(
467             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
468             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
469   }
470 
471   @Test
472   @SuppressWarnings("all")
getNoteExceptionTest()473   public void getNoteExceptionTest() throws Exception {
474     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
475     mockGrafeasV1Beta1.addException(exception);
476 
477     try {
478       NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
479 
480       client.getNote(name);
481       Assert.fail("No exception raised");
482     } catch (InvalidArgumentException e) {
483       // Expected exception
484     }
485   }
486 
487   @Test
488   @SuppressWarnings("all")
listNotesTest()489   public void listNotesTest() {
490     String nextPageToken = "";
491     Note notesElement = Note.newBuilder().build();
492     List<Note> notes = Arrays.asList(notesElement);
493     ListNotesResponse expectedResponse =
494         ListNotesResponse.newBuilder().setNextPageToken(nextPageToken).addAllNotes(notes).build();
495     mockGrafeasV1Beta1.addResponse(expectedResponse);
496 
497     ProjectName parent = ProjectName.of("[PROJECT]");
498     String filter = "filter-1274492040";
499 
500     ListNotesPagedResponse pagedListResponse = client.listNotes(parent, filter);
501 
502     List<Note> resources = Lists.newArrayList(pagedListResponse.iterateAll());
503     Assert.assertEquals(1, resources.size());
504     Assert.assertEquals(expectedResponse.getNotesList().get(0), resources.get(0));
505 
506     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
507     Assert.assertEquals(1, actualRequests.size());
508     ListNotesRequest actualRequest = (ListNotesRequest) actualRequests.get(0);
509 
510     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
511     Assert.assertEquals(filter, actualRequest.getFilter());
512     Assert.assertTrue(
513         channelProvider.isHeaderSent(
514             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
515             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
516   }
517 
518   @Test
519   @SuppressWarnings("all")
listNotesExceptionTest()520   public void listNotesExceptionTest() throws Exception {
521     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
522     mockGrafeasV1Beta1.addException(exception);
523 
524     try {
525       ProjectName parent = ProjectName.of("[PROJECT]");
526       String filter = "filter-1274492040";
527 
528       client.listNotes(parent, filter);
529       Assert.fail("No exception raised");
530     } catch (InvalidArgumentException e) {
531       // Expected exception
532     }
533   }
534 
535   @Test
536   @SuppressWarnings("all")
deleteNoteTest()537   public void deleteNoteTest() {
538     Empty expectedResponse = Empty.newBuilder().build();
539     mockGrafeasV1Beta1.addResponse(expectedResponse);
540 
541     NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
542 
543     client.deleteNote(name);
544 
545     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
546     Assert.assertEquals(1, actualRequests.size());
547     DeleteNoteRequest actualRequest = (DeleteNoteRequest) actualRequests.get(0);
548 
549     Assert.assertEquals(name, NoteName.parse(actualRequest.getName()));
550     Assert.assertTrue(
551         channelProvider.isHeaderSent(
552             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
553             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
554   }
555 
556   @Test
557   @SuppressWarnings("all")
deleteNoteExceptionTest()558   public void deleteNoteExceptionTest() throws Exception {
559     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
560     mockGrafeasV1Beta1.addException(exception);
561 
562     try {
563       NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
564 
565       client.deleteNote(name);
566       Assert.fail("No exception raised");
567     } catch (InvalidArgumentException e) {
568       // Expected exception
569     }
570   }
571 
572   @Test
573   @SuppressWarnings("all")
createNoteTest()574   public void createNoteTest() {
575     String name = "name3373707";
576     String shortDescription = "shortDescription-235369287";
577     String longDescription = "longDescription-1747792199";
578     Note expectedResponse =
579         Note.newBuilder()
580             .setName(name)
581             .setShortDescription(shortDescription)
582             .setLongDescription(longDescription)
583             .build();
584     mockGrafeasV1Beta1.addResponse(expectedResponse);
585 
586     ProjectName parent = ProjectName.of("[PROJECT]");
587     String noteId = "noteId2129224840";
588     Note note = Note.newBuilder().build();
589 
590     Note actualResponse = client.createNote(parent, noteId, note);
591     Assert.assertEquals(expectedResponse, actualResponse);
592 
593     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
594     Assert.assertEquals(1, actualRequests.size());
595     CreateNoteRequest actualRequest = (CreateNoteRequest) actualRequests.get(0);
596 
597     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
598     Assert.assertEquals(noteId, actualRequest.getNoteId());
599     Assert.assertEquals(note, actualRequest.getNote());
600     Assert.assertTrue(
601         channelProvider.isHeaderSent(
602             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
603             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
604   }
605 
606   @Test
607   @SuppressWarnings("all")
createNoteExceptionTest()608   public void createNoteExceptionTest() throws Exception {
609     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
610     mockGrafeasV1Beta1.addException(exception);
611 
612     try {
613       ProjectName parent = ProjectName.of("[PROJECT]");
614       String noteId = "noteId2129224840";
615       Note note = Note.newBuilder().build();
616 
617       client.createNote(parent, noteId, note);
618       Assert.fail("No exception raised");
619     } catch (InvalidArgumentException e) {
620       // Expected exception
621     }
622   }
623 
624   @Test
625   @SuppressWarnings("all")
batchCreateNotesTest()626   public void batchCreateNotesTest() {
627     BatchCreateNotesResponse expectedResponse = BatchCreateNotesResponse.newBuilder().build();
628     mockGrafeasV1Beta1.addResponse(expectedResponse);
629 
630     ProjectName parent = ProjectName.of("[PROJECT]");
631     Map<String, Note> notes = new HashMap<>();
632 
633     BatchCreateNotesResponse actualResponse = client.batchCreateNotes(parent, notes);
634     Assert.assertEquals(expectedResponse, actualResponse);
635 
636     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
637     Assert.assertEquals(1, actualRequests.size());
638     BatchCreateNotesRequest actualRequest = (BatchCreateNotesRequest) actualRequests.get(0);
639 
640     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
641     Assert.assertEquals(notes, actualRequest.getNotesMap());
642     Assert.assertTrue(
643         channelProvider.isHeaderSent(
644             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
645             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
646   }
647 
648   @Test
649   @SuppressWarnings("all")
batchCreateNotesExceptionTest()650   public void batchCreateNotesExceptionTest() throws Exception {
651     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
652     mockGrafeasV1Beta1.addException(exception);
653 
654     try {
655       ProjectName parent = ProjectName.of("[PROJECT]");
656       Map<String, Note> notes = new HashMap<>();
657 
658       client.batchCreateNotes(parent, notes);
659       Assert.fail("No exception raised");
660     } catch (InvalidArgumentException e) {
661       // Expected exception
662     }
663   }
664 
665   @Test
666   @SuppressWarnings("all")
updateNoteTest()667   public void updateNoteTest() {
668     String name2 = "name2-1052831874";
669     String shortDescription = "shortDescription-235369287";
670     String longDescription = "longDescription-1747792199";
671     Note expectedResponse =
672         Note.newBuilder()
673             .setName(name2)
674             .setShortDescription(shortDescription)
675             .setLongDescription(longDescription)
676             .build();
677     mockGrafeasV1Beta1.addResponse(expectedResponse);
678 
679     NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
680     Note note = Note.newBuilder().build();
681     FieldMask updateMask = FieldMask.newBuilder().build();
682 
683     Note actualResponse = client.updateNote(name, note, updateMask);
684     Assert.assertEquals(expectedResponse, actualResponse);
685 
686     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
687     Assert.assertEquals(1, actualRequests.size());
688     UpdateNoteRequest actualRequest = (UpdateNoteRequest) actualRequests.get(0);
689 
690     Assert.assertEquals(name, NoteName.parse(actualRequest.getName()));
691     Assert.assertEquals(note, actualRequest.getNote());
692     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
693     Assert.assertTrue(
694         channelProvider.isHeaderSent(
695             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
696             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
697   }
698 
699   @Test
700   @SuppressWarnings("all")
updateNoteExceptionTest()701   public void updateNoteExceptionTest() throws Exception {
702     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
703     mockGrafeasV1Beta1.addException(exception);
704 
705     try {
706       NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
707       Note note = Note.newBuilder().build();
708       FieldMask updateMask = FieldMask.newBuilder().build();
709 
710       client.updateNote(name, note, updateMask);
711       Assert.fail("No exception raised");
712     } catch (InvalidArgumentException e) {
713       // Expected exception
714     }
715   }
716 
717   @Test
718   @SuppressWarnings("all")
listNoteOccurrencesTest()719   public void listNoteOccurrencesTest() {
720     String nextPageToken = "";
721     Occurrence occurrencesElement = Occurrence.newBuilder().build();
722     List<Occurrence> occurrences = Arrays.asList(occurrencesElement);
723     ListNoteOccurrencesResponse expectedResponse =
724         ListNoteOccurrencesResponse.newBuilder()
725             .setNextPageToken(nextPageToken)
726             .addAllOccurrences(occurrences)
727             .build();
728     mockGrafeasV1Beta1.addResponse(expectedResponse);
729 
730     NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
731     String filter = "filter-1274492040";
732 
733     ListNoteOccurrencesPagedResponse pagedListResponse = client.listNoteOccurrences(name, filter);
734 
735     List<Occurrence> resources = Lists.newArrayList(pagedListResponse.iterateAll());
736     Assert.assertEquals(1, resources.size());
737     Assert.assertEquals(expectedResponse.getOccurrencesList().get(0), resources.get(0));
738 
739     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
740     Assert.assertEquals(1, actualRequests.size());
741     ListNoteOccurrencesRequest actualRequest = (ListNoteOccurrencesRequest) actualRequests.get(0);
742 
743     Assert.assertEquals(name, NoteName.parse(actualRequest.getName()));
744     Assert.assertEquals(filter, actualRequest.getFilter());
745     Assert.assertTrue(
746         channelProvider.isHeaderSent(
747             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
748             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
749   }
750 
751   @Test
752   @SuppressWarnings("all")
listNoteOccurrencesExceptionTest()753   public void listNoteOccurrencesExceptionTest() throws Exception {
754     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
755     mockGrafeasV1Beta1.addException(exception);
756 
757     try {
758       NoteName name = NoteName.of("[PROJECT]", "[NOTE]");
759       String filter = "filter-1274492040";
760 
761       client.listNoteOccurrences(name, filter);
762       Assert.fail("No exception raised");
763     } catch (InvalidArgumentException e) {
764       // Expected exception
765     }
766   }
767 
768   @Test
769   @SuppressWarnings("all")
getVulnerabilityOccurrencesSummaryTest()770   public void getVulnerabilityOccurrencesSummaryTest() {
771     VulnerabilityOccurrencesSummary expectedResponse =
772         VulnerabilityOccurrencesSummary.newBuilder().build();
773     mockGrafeasV1Beta1.addResponse(expectedResponse);
774 
775     ProjectName parent = ProjectName.of("[PROJECT]");
776     String filter = "filter-1274492040";
777 
778     VulnerabilityOccurrencesSummary actualResponse =
779         client.getVulnerabilityOccurrencesSummary(parent, filter);
780     Assert.assertEquals(expectedResponse, actualResponse);
781 
782     List<AbstractMessage> actualRequests = mockGrafeasV1Beta1.getRequests();
783     Assert.assertEquals(1, actualRequests.size());
784     GetVulnerabilityOccurrencesSummaryRequest actualRequest =
785         (GetVulnerabilityOccurrencesSummaryRequest) actualRequests.get(0);
786 
787     Assert.assertEquals(parent, ProjectName.parse(actualRequest.getParent()));
788     Assert.assertEquals(filter, actualRequest.getFilter());
789     Assert.assertTrue(
790         channelProvider.isHeaderSent(
791             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
792             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
793   }
794 
795   @Test
796   @SuppressWarnings("all")
getVulnerabilityOccurrencesSummaryExceptionTest()797   public void getVulnerabilityOccurrencesSummaryExceptionTest() throws Exception {
798     StatusRuntimeException exception = new StatusRuntimeException(Status.INVALID_ARGUMENT);
799     mockGrafeasV1Beta1.addException(exception);
800 
801     try {
802       ProjectName parent = ProjectName.of("[PROJECT]");
803       String filter = "filter-1274492040";
804 
805       client.getVulnerabilityOccurrencesSummary(parent, filter);
806       Assert.fail("No exception raised");
807     } catch (InvalidArgumentException e) {
808       // Expected exception
809     }
810   }
811 }
812