• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 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 
17 package com.google.cloud.dialogflow.cx.v3;
18 
19 import static com.google.cloud.dialogflow.cx.v3.EnvironmentsClient.ListContinuousTestResultsPagedResponse;
20 import static com.google.cloud.dialogflow.cx.v3.EnvironmentsClient.ListEnvironmentsPagedResponse;
21 import static com.google.cloud.dialogflow.cx.v3.EnvironmentsClient.ListLocationsPagedResponse;
22 import static com.google.cloud.dialogflow.cx.v3.EnvironmentsClient.LookupEnvironmentHistoryPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.grpc.GaxGrpcProperties;
26 import com.google.api.gax.grpc.testing.LocalChannelProvider;
27 import com.google.api.gax.grpc.testing.MockGrpcService;
28 import com.google.api.gax.grpc.testing.MockServiceHelper;
29 import com.google.api.gax.rpc.ApiClientHeaderProvider;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.cloud.location.GetLocationRequest;
33 import com.google.cloud.location.ListLocationsRequest;
34 import com.google.cloud.location.ListLocationsResponse;
35 import com.google.cloud.location.Location;
36 import com.google.common.collect.Lists;
37 import com.google.longrunning.Operation;
38 import com.google.protobuf.AbstractMessage;
39 import com.google.protobuf.Any;
40 import com.google.protobuf.Empty;
41 import com.google.protobuf.FieldMask;
42 import com.google.protobuf.Timestamp;
43 import io.grpc.StatusRuntimeException;
44 import java.io.IOException;
45 import java.util.ArrayList;
46 import java.util.Arrays;
47 import java.util.HashMap;
48 import java.util.List;
49 import java.util.UUID;
50 import java.util.concurrent.ExecutionException;
51 import javax.annotation.Generated;
52 import org.junit.After;
53 import org.junit.AfterClass;
54 import org.junit.Assert;
55 import org.junit.Before;
56 import org.junit.BeforeClass;
57 import org.junit.Test;
58 
59 @Generated("by gapic-generator-java")
60 public class EnvironmentsClientTest {
61   private static MockEnvironments mockEnvironments;
62   private static MockLocations mockLocations;
63   private static MockServiceHelper mockServiceHelper;
64   private LocalChannelProvider channelProvider;
65   private EnvironmentsClient client;
66 
67   @BeforeClass
startStaticServer()68   public static void startStaticServer() {
69     mockEnvironments = new MockEnvironments();
70     mockLocations = new MockLocations();
71     mockServiceHelper =
72         new MockServiceHelper(
73             UUID.randomUUID().toString(),
74             Arrays.<MockGrpcService>asList(mockEnvironments, mockLocations));
75     mockServiceHelper.start();
76   }
77 
78   @AfterClass
stopServer()79   public static void stopServer() {
80     mockServiceHelper.stop();
81   }
82 
83   @Before
setUp()84   public void setUp() throws IOException {
85     mockServiceHelper.reset();
86     channelProvider = mockServiceHelper.createChannelProvider();
87     EnvironmentsSettings settings =
88         EnvironmentsSettings.newBuilder()
89             .setTransportChannelProvider(channelProvider)
90             .setCredentialsProvider(NoCredentialsProvider.create())
91             .build();
92     client = EnvironmentsClient.create(settings);
93   }
94 
95   @After
tearDown()96   public void tearDown() throws Exception {
97     client.close();
98   }
99 
100   @Test
listEnvironmentsTest()101   public void listEnvironmentsTest() throws Exception {
102     Environment responsesElement = Environment.newBuilder().build();
103     ListEnvironmentsResponse expectedResponse =
104         ListEnvironmentsResponse.newBuilder()
105             .setNextPageToken("")
106             .addAllEnvironments(Arrays.asList(responsesElement))
107             .build();
108     mockEnvironments.addResponse(expectedResponse);
109 
110     AgentName parent = AgentName.of("[PROJECT]", "[LOCATION]", "[AGENT]");
111 
112     ListEnvironmentsPagedResponse pagedListResponse = client.listEnvironments(parent);
113 
114     List<Environment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
115 
116     Assert.assertEquals(1, resources.size());
117     Assert.assertEquals(expectedResponse.getEnvironmentsList().get(0), resources.get(0));
118 
119     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
120     Assert.assertEquals(1, actualRequests.size());
121     ListEnvironmentsRequest actualRequest = ((ListEnvironmentsRequest) actualRequests.get(0));
122 
123     Assert.assertEquals(parent.toString(), actualRequest.getParent());
124     Assert.assertTrue(
125         channelProvider.isHeaderSent(
126             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
127             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
128   }
129 
130   @Test
listEnvironmentsExceptionTest()131   public void listEnvironmentsExceptionTest() throws Exception {
132     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
133     mockEnvironments.addException(exception);
134 
135     try {
136       AgentName parent = AgentName.of("[PROJECT]", "[LOCATION]", "[AGENT]");
137       client.listEnvironments(parent);
138       Assert.fail("No exception raised");
139     } catch (InvalidArgumentException e) {
140       // Expected exception.
141     }
142   }
143 
144   @Test
listEnvironmentsTest2()145   public void listEnvironmentsTest2() throws Exception {
146     Environment responsesElement = Environment.newBuilder().build();
147     ListEnvironmentsResponse expectedResponse =
148         ListEnvironmentsResponse.newBuilder()
149             .setNextPageToken("")
150             .addAllEnvironments(Arrays.asList(responsesElement))
151             .build();
152     mockEnvironments.addResponse(expectedResponse);
153 
154     String parent = "parent-995424086";
155 
156     ListEnvironmentsPagedResponse pagedListResponse = client.listEnvironments(parent);
157 
158     List<Environment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
159 
160     Assert.assertEquals(1, resources.size());
161     Assert.assertEquals(expectedResponse.getEnvironmentsList().get(0), resources.get(0));
162 
163     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
164     Assert.assertEquals(1, actualRequests.size());
165     ListEnvironmentsRequest actualRequest = ((ListEnvironmentsRequest) actualRequests.get(0));
166 
167     Assert.assertEquals(parent, actualRequest.getParent());
168     Assert.assertTrue(
169         channelProvider.isHeaderSent(
170             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
171             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
172   }
173 
174   @Test
listEnvironmentsExceptionTest2()175   public void listEnvironmentsExceptionTest2() throws Exception {
176     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
177     mockEnvironments.addException(exception);
178 
179     try {
180       String parent = "parent-995424086";
181       client.listEnvironments(parent);
182       Assert.fail("No exception raised");
183     } catch (InvalidArgumentException e) {
184       // Expected exception.
185     }
186   }
187 
188   @Test
getEnvironmentTest()189   public void getEnvironmentTest() throws Exception {
190     Environment expectedResponse =
191         Environment.newBuilder()
192             .setName(
193                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
194                     .toString())
195             .setDisplayName("displayName1714148973")
196             .setDescription("description-1724546052")
197             .addAllVersionConfigs(new ArrayList<Environment.VersionConfig>())
198             .setUpdateTime(Timestamp.newBuilder().build())
199             .setTestCasesConfig(Environment.TestCasesConfig.newBuilder().build())
200             .setWebhookConfig(Environment.WebhookConfig.newBuilder().build())
201             .build();
202     mockEnvironments.addResponse(expectedResponse);
203 
204     EnvironmentName name =
205         EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
206 
207     Environment actualResponse = client.getEnvironment(name);
208     Assert.assertEquals(expectedResponse, actualResponse);
209 
210     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
211     Assert.assertEquals(1, actualRequests.size());
212     GetEnvironmentRequest actualRequest = ((GetEnvironmentRequest) actualRequests.get(0));
213 
214     Assert.assertEquals(name.toString(), actualRequest.getName());
215     Assert.assertTrue(
216         channelProvider.isHeaderSent(
217             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
218             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
219   }
220 
221   @Test
getEnvironmentExceptionTest()222   public void getEnvironmentExceptionTest() throws Exception {
223     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
224     mockEnvironments.addException(exception);
225 
226     try {
227       EnvironmentName name =
228           EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
229       client.getEnvironment(name);
230       Assert.fail("No exception raised");
231     } catch (InvalidArgumentException e) {
232       // Expected exception.
233     }
234   }
235 
236   @Test
getEnvironmentTest2()237   public void getEnvironmentTest2() throws Exception {
238     Environment expectedResponse =
239         Environment.newBuilder()
240             .setName(
241                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
242                     .toString())
243             .setDisplayName("displayName1714148973")
244             .setDescription("description-1724546052")
245             .addAllVersionConfigs(new ArrayList<Environment.VersionConfig>())
246             .setUpdateTime(Timestamp.newBuilder().build())
247             .setTestCasesConfig(Environment.TestCasesConfig.newBuilder().build())
248             .setWebhookConfig(Environment.WebhookConfig.newBuilder().build())
249             .build();
250     mockEnvironments.addResponse(expectedResponse);
251 
252     String name = "name3373707";
253 
254     Environment actualResponse = client.getEnvironment(name);
255     Assert.assertEquals(expectedResponse, actualResponse);
256 
257     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
258     Assert.assertEquals(1, actualRequests.size());
259     GetEnvironmentRequest actualRequest = ((GetEnvironmentRequest) actualRequests.get(0));
260 
261     Assert.assertEquals(name, actualRequest.getName());
262     Assert.assertTrue(
263         channelProvider.isHeaderSent(
264             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
265             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
266   }
267 
268   @Test
getEnvironmentExceptionTest2()269   public void getEnvironmentExceptionTest2() throws Exception {
270     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
271     mockEnvironments.addException(exception);
272 
273     try {
274       String name = "name3373707";
275       client.getEnvironment(name);
276       Assert.fail("No exception raised");
277     } catch (InvalidArgumentException e) {
278       // Expected exception.
279     }
280   }
281 
282   @Test
createEnvironmentTest()283   public void createEnvironmentTest() throws Exception {
284     Environment expectedResponse =
285         Environment.newBuilder()
286             .setName(
287                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
288                     .toString())
289             .setDisplayName("displayName1714148973")
290             .setDescription("description-1724546052")
291             .addAllVersionConfigs(new ArrayList<Environment.VersionConfig>())
292             .setUpdateTime(Timestamp.newBuilder().build())
293             .setTestCasesConfig(Environment.TestCasesConfig.newBuilder().build())
294             .setWebhookConfig(Environment.WebhookConfig.newBuilder().build())
295             .build();
296     Operation resultOperation =
297         Operation.newBuilder()
298             .setName("createEnvironmentTest")
299             .setDone(true)
300             .setResponse(Any.pack(expectedResponse))
301             .build();
302     mockEnvironments.addResponse(resultOperation);
303 
304     AgentName parent = AgentName.of("[PROJECT]", "[LOCATION]", "[AGENT]");
305     Environment environment = Environment.newBuilder().build();
306 
307     Environment actualResponse = client.createEnvironmentAsync(parent, environment).get();
308     Assert.assertEquals(expectedResponse, actualResponse);
309 
310     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
311     Assert.assertEquals(1, actualRequests.size());
312     CreateEnvironmentRequest actualRequest = ((CreateEnvironmentRequest) actualRequests.get(0));
313 
314     Assert.assertEquals(parent.toString(), actualRequest.getParent());
315     Assert.assertEquals(environment, actualRequest.getEnvironment());
316     Assert.assertTrue(
317         channelProvider.isHeaderSent(
318             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
319             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
320   }
321 
322   @Test
createEnvironmentExceptionTest()323   public void createEnvironmentExceptionTest() throws Exception {
324     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
325     mockEnvironments.addException(exception);
326 
327     try {
328       AgentName parent = AgentName.of("[PROJECT]", "[LOCATION]", "[AGENT]");
329       Environment environment = Environment.newBuilder().build();
330       client.createEnvironmentAsync(parent, environment).get();
331       Assert.fail("No exception raised");
332     } catch (ExecutionException e) {
333       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
334       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
335       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
336     }
337   }
338 
339   @Test
createEnvironmentTest2()340   public void createEnvironmentTest2() throws Exception {
341     Environment expectedResponse =
342         Environment.newBuilder()
343             .setName(
344                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
345                     .toString())
346             .setDisplayName("displayName1714148973")
347             .setDescription("description-1724546052")
348             .addAllVersionConfigs(new ArrayList<Environment.VersionConfig>())
349             .setUpdateTime(Timestamp.newBuilder().build())
350             .setTestCasesConfig(Environment.TestCasesConfig.newBuilder().build())
351             .setWebhookConfig(Environment.WebhookConfig.newBuilder().build())
352             .build();
353     Operation resultOperation =
354         Operation.newBuilder()
355             .setName("createEnvironmentTest")
356             .setDone(true)
357             .setResponse(Any.pack(expectedResponse))
358             .build();
359     mockEnvironments.addResponse(resultOperation);
360 
361     String parent = "parent-995424086";
362     Environment environment = Environment.newBuilder().build();
363 
364     Environment actualResponse = client.createEnvironmentAsync(parent, environment).get();
365     Assert.assertEquals(expectedResponse, actualResponse);
366 
367     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
368     Assert.assertEquals(1, actualRequests.size());
369     CreateEnvironmentRequest actualRequest = ((CreateEnvironmentRequest) actualRequests.get(0));
370 
371     Assert.assertEquals(parent, actualRequest.getParent());
372     Assert.assertEquals(environment, actualRequest.getEnvironment());
373     Assert.assertTrue(
374         channelProvider.isHeaderSent(
375             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
376             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
377   }
378 
379   @Test
createEnvironmentExceptionTest2()380   public void createEnvironmentExceptionTest2() throws Exception {
381     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
382     mockEnvironments.addException(exception);
383 
384     try {
385       String parent = "parent-995424086";
386       Environment environment = Environment.newBuilder().build();
387       client.createEnvironmentAsync(parent, environment).get();
388       Assert.fail("No exception raised");
389     } catch (ExecutionException e) {
390       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
391       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
392       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
393     }
394   }
395 
396   @Test
updateEnvironmentTest()397   public void updateEnvironmentTest() throws Exception {
398     Environment expectedResponse =
399         Environment.newBuilder()
400             .setName(
401                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
402                     .toString())
403             .setDisplayName("displayName1714148973")
404             .setDescription("description-1724546052")
405             .addAllVersionConfigs(new ArrayList<Environment.VersionConfig>())
406             .setUpdateTime(Timestamp.newBuilder().build())
407             .setTestCasesConfig(Environment.TestCasesConfig.newBuilder().build())
408             .setWebhookConfig(Environment.WebhookConfig.newBuilder().build())
409             .build();
410     Operation resultOperation =
411         Operation.newBuilder()
412             .setName("updateEnvironmentTest")
413             .setDone(true)
414             .setResponse(Any.pack(expectedResponse))
415             .build();
416     mockEnvironments.addResponse(resultOperation);
417 
418     Environment environment = Environment.newBuilder().build();
419     FieldMask updateMask = FieldMask.newBuilder().build();
420 
421     Environment actualResponse = client.updateEnvironmentAsync(environment, updateMask).get();
422     Assert.assertEquals(expectedResponse, actualResponse);
423 
424     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
425     Assert.assertEquals(1, actualRequests.size());
426     UpdateEnvironmentRequest actualRequest = ((UpdateEnvironmentRequest) actualRequests.get(0));
427 
428     Assert.assertEquals(environment, actualRequest.getEnvironment());
429     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
430     Assert.assertTrue(
431         channelProvider.isHeaderSent(
432             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
433             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
434   }
435 
436   @Test
updateEnvironmentExceptionTest()437   public void updateEnvironmentExceptionTest() throws Exception {
438     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
439     mockEnvironments.addException(exception);
440 
441     try {
442       Environment environment = Environment.newBuilder().build();
443       FieldMask updateMask = FieldMask.newBuilder().build();
444       client.updateEnvironmentAsync(environment, updateMask).get();
445       Assert.fail("No exception raised");
446     } catch (ExecutionException e) {
447       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
448       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
449       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
450     }
451   }
452 
453   @Test
deleteEnvironmentTest()454   public void deleteEnvironmentTest() throws Exception {
455     Empty expectedResponse = Empty.newBuilder().build();
456     mockEnvironments.addResponse(expectedResponse);
457 
458     EnvironmentName name =
459         EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
460 
461     client.deleteEnvironment(name);
462 
463     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
464     Assert.assertEquals(1, actualRequests.size());
465     DeleteEnvironmentRequest actualRequest = ((DeleteEnvironmentRequest) actualRequests.get(0));
466 
467     Assert.assertEquals(name.toString(), actualRequest.getName());
468     Assert.assertTrue(
469         channelProvider.isHeaderSent(
470             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
471             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
472   }
473 
474   @Test
deleteEnvironmentExceptionTest()475   public void deleteEnvironmentExceptionTest() throws Exception {
476     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
477     mockEnvironments.addException(exception);
478 
479     try {
480       EnvironmentName name =
481           EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
482       client.deleteEnvironment(name);
483       Assert.fail("No exception raised");
484     } catch (InvalidArgumentException e) {
485       // Expected exception.
486     }
487   }
488 
489   @Test
deleteEnvironmentTest2()490   public void deleteEnvironmentTest2() throws Exception {
491     Empty expectedResponse = Empty.newBuilder().build();
492     mockEnvironments.addResponse(expectedResponse);
493 
494     String name = "name3373707";
495 
496     client.deleteEnvironment(name);
497 
498     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
499     Assert.assertEquals(1, actualRequests.size());
500     DeleteEnvironmentRequest actualRequest = ((DeleteEnvironmentRequest) actualRequests.get(0));
501 
502     Assert.assertEquals(name, actualRequest.getName());
503     Assert.assertTrue(
504         channelProvider.isHeaderSent(
505             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
506             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
507   }
508 
509   @Test
deleteEnvironmentExceptionTest2()510   public void deleteEnvironmentExceptionTest2() throws Exception {
511     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
512     mockEnvironments.addException(exception);
513 
514     try {
515       String name = "name3373707";
516       client.deleteEnvironment(name);
517       Assert.fail("No exception raised");
518     } catch (InvalidArgumentException e) {
519       // Expected exception.
520     }
521   }
522 
523   @Test
lookupEnvironmentHistoryTest()524   public void lookupEnvironmentHistoryTest() throws Exception {
525     Environment responsesElement = Environment.newBuilder().build();
526     LookupEnvironmentHistoryResponse expectedResponse =
527         LookupEnvironmentHistoryResponse.newBuilder()
528             .setNextPageToken("")
529             .addAllEnvironments(Arrays.asList(responsesElement))
530             .build();
531     mockEnvironments.addResponse(expectedResponse);
532 
533     EnvironmentName name =
534         EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
535 
536     LookupEnvironmentHistoryPagedResponse pagedListResponse = client.lookupEnvironmentHistory(name);
537 
538     List<Environment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
539 
540     Assert.assertEquals(1, resources.size());
541     Assert.assertEquals(expectedResponse.getEnvironmentsList().get(0), resources.get(0));
542 
543     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
544     Assert.assertEquals(1, actualRequests.size());
545     LookupEnvironmentHistoryRequest actualRequest =
546         ((LookupEnvironmentHistoryRequest) actualRequests.get(0));
547 
548     Assert.assertEquals(name.toString(), actualRequest.getName());
549     Assert.assertTrue(
550         channelProvider.isHeaderSent(
551             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
552             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
553   }
554 
555   @Test
lookupEnvironmentHistoryExceptionTest()556   public void lookupEnvironmentHistoryExceptionTest() throws Exception {
557     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
558     mockEnvironments.addException(exception);
559 
560     try {
561       EnvironmentName name =
562           EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
563       client.lookupEnvironmentHistory(name);
564       Assert.fail("No exception raised");
565     } catch (InvalidArgumentException e) {
566       // Expected exception.
567     }
568   }
569 
570   @Test
lookupEnvironmentHistoryTest2()571   public void lookupEnvironmentHistoryTest2() throws Exception {
572     Environment responsesElement = Environment.newBuilder().build();
573     LookupEnvironmentHistoryResponse expectedResponse =
574         LookupEnvironmentHistoryResponse.newBuilder()
575             .setNextPageToken("")
576             .addAllEnvironments(Arrays.asList(responsesElement))
577             .build();
578     mockEnvironments.addResponse(expectedResponse);
579 
580     String name = "name3373707";
581 
582     LookupEnvironmentHistoryPagedResponse pagedListResponse = client.lookupEnvironmentHistory(name);
583 
584     List<Environment> resources = Lists.newArrayList(pagedListResponse.iterateAll());
585 
586     Assert.assertEquals(1, resources.size());
587     Assert.assertEquals(expectedResponse.getEnvironmentsList().get(0), resources.get(0));
588 
589     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
590     Assert.assertEquals(1, actualRequests.size());
591     LookupEnvironmentHistoryRequest actualRequest =
592         ((LookupEnvironmentHistoryRequest) actualRequests.get(0));
593 
594     Assert.assertEquals(name, actualRequest.getName());
595     Assert.assertTrue(
596         channelProvider.isHeaderSent(
597             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
598             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
599   }
600 
601   @Test
lookupEnvironmentHistoryExceptionTest2()602   public void lookupEnvironmentHistoryExceptionTest2() throws Exception {
603     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
604     mockEnvironments.addException(exception);
605 
606     try {
607       String name = "name3373707";
608       client.lookupEnvironmentHistory(name);
609       Assert.fail("No exception raised");
610     } catch (InvalidArgumentException e) {
611       // Expected exception.
612     }
613   }
614 
615   @Test
runContinuousTestTest()616   public void runContinuousTestTest() throws Exception {
617     RunContinuousTestResponse expectedResponse =
618         RunContinuousTestResponse.newBuilder()
619             .setContinuousTestResult(ContinuousTestResult.newBuilder().build())
620             .build();
621     Operation resultOperation =
622         Operation.newBuilder()
623             .setName("runContinuousTestTest")
624             .setDone(true)
625             .setResponse(Any.pack(expectedResponse))
626             .build();
627     mockEnvironments.addResponse(resultOperation);
628 
629     RunContinuousTestRequest request =
630         RunContinuousTestRequest.newBuilder()
631             .setEnvironment(
632                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
633                     .toString())
634             .build();
635 
636     RunContinuousTestResponse actualResponse = client.runContinuousTestAsync(request).get();
637     Assert.assertEquals(expectedResponse, actualResponse);
638 
639     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
640     Assert.assertEquals(1, actualRequests.size());
641     RunContinuousTestRequest actualRequest = ((RunContinuousTestRequest) actualRequests.get(0));
642 
643     Assert.assertEquals(request.getEnvironment(), actualRequest.getEnvironment());
644     Assert.assertTrue(
645         channelProvider.isHeaderSent(
646             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
647             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
648   }
649 
650   @Test
runContinuousTestExceptionTest()651   public void runContinuousTestExceptionTest() throws Exception {
652     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
653     mockEnvironments.addException(exception);
654 
655     try {
656       RunContinuousTestRequest request =
657           RunContinuousTestRequest.newBuilder()
658               .setEnvironment(
659                   EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
660                       .toString())
661               .build();
662       client.runContinuousTestAsync(request).get();
663       Assert.fail("No exception raised");
664     } catch (ExecutionException e) {
665       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
666       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
667       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
668     }
669   }
670 
671   @Test
listContinuousTestResultsTest()672   public void listContinuousTestResultsTest() throws Exception {
673     ContinuousTestResult responsesElement = ContinuousTestResult.newBuilder().build();
674     ListContinuousTestResultsResponse expectedResponse =
675         ListContinuousTestResultsResponse.newBuilder()
676             .setNextPageToken("")
677             .addAllContinuousTestResults(Arrays.asList(responsesElement))
678             .build();
679     mockEnvironments.addResponse(expectedResponse);
680 
681     EnvironmentName parent =
682         EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
683 
684     ListContinuousTestResultsPagedResponse pagedListResponse =
685         client.listContinuousTestResults(parent);
686 
687     List<ContinuousTestResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
688 
689     Assert.assertEquals(1, resources.size());
690     Assert.assertEquals(expectedResponse.getContinuousTestResultsList().get(0), resources.get(0));
691 
692     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
693     Assert.assertEquals(1, actualRequests.size());
694     ListContinuousTestResultsRequest actualRequest =
695         ((ListContinuousTestResultsRequest) actualRequests.get(0));
696 
697     Assert.assertEquals(parent.toString(), actualRequest.getParent());
698     Assert.assertTrue(
699         channelProvider.isHeaderSent(
700             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
701             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
702   }
703 
704   @Test
listContinuousTestResultsExceptionTest()705   public void listContinuousTestResultsExceptionTest() throws Exception {
706     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
707     mockEnvironments.addException(exception);
708 
709     try {
710       EnvironmentName parent =
711           EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]");
712       client.listContinuousTestResults(parent);
713       Assert.fail("No exception raised");
714     } catch (InvalidArgumentException e) {
715       // Expected exception.
716     }
717   }
718 
719   @Test
listContinuousTestResultsTest2()720   public void listContinuousTestResultsTest2() throws Exception {
721     ContinuousTestResult responsesElement = ContinuousTestResult.newBuilder().build();
722     ListContinuousTestResultsResponse expectedResponse =
723         ListContinuousTestResultsResponse.newBuilder()
724             .setNextPageToken("")
725             .addAllContinuousTestResults(Arrays.asList(responsesElement))
726             .build();
727     mockEnvironments.addResponse(expectedResponse);
728 
729     String parent = "parent-995424086";
730 
731     ListContinuousTestResultsPagedResponse pagedListResponse =
732         client.listContinuousTestResults(parent);
733 
734     List<ContinuousTestResult> resources = Lists.newArrayList(pagedListResponse.iterateAll());
735 
736     Assert.assertEquals(1, resources.size());
737     Assert.assertEquals(expectedResponse.getContinuousTestResultsList().get(0), resources.get(0));
738 
739     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
740     Assert.assertEquals(1, actualRequests.size());
741     ListContinuousTestResultsRequest actualRequest =
742         ((ListContinuousTestResultsRequest) actualRequests.get(0));
743 
744     Assert.assertEquals(parent, actualRequest.getParent());
745     Assert.assertTrue(
746         channelProvider.isHeaderSent(
747             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
748             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
749   }
750 
751   @Test
listContinuousTestResultsExceptionTest2()752   public void listContinuousTestResultsExceptionTest2() throws Exception {
753     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
754     mockEnvironments.addException(exception);
755 
756     try {
757       String parent = "parent-995424086";
758       client.listContinuousTestResults(parent);
759       Assert.fail("No exception raised");
760     } catch (InvalidArgumentException e) {
761       // Expected exception.
762     }
763   }
764 
765   @Test
deployFlowTest()766   public void deployFlowTest() throws Exception {
767     DeployFlowResponse expectedResponse =
768         DeployFlowResponse.newBuilder()
769             .setEnvironment(Environment.newBuilder().build())
770             .setDeployment("deployment1939520197")
771             .build();
772     Operation resultOperation =
773         Operation.newBuilder()
774             .setName("deployFlowTest")
775             .setDone(true)
776             .setResponse(Any.pack(expectedResponse))
777             .build();
778     mockEnvironments.addResponse(resultOperation);
779 
780     DeployFlowRequest request =
781         DeployFlowRequest.newBuilder()
782             .setEnvironment(
783                 EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
784                     .toString())
785             .setFlowVersion(
786                 VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
787                     .toString())
788             .build();
789 
790     DeployFlowResponse actualResponse = client.deployFlowAsync(request).get();
791     Assert.assertEquals(expectedResponse, actualResponse);
792 
793     List<AbstractMessage> actualRequests = mockEnvironments.getRequests();
794     Assert.assertEquals(1, actualRequests.size());
795     DeployFlowRequest actualRequest = ((DeployFlowRequest) actualRequests.get(0));
796 
797     Assert.assertEquals(request.getEnvironment(), actualRequest.getEnvironment());
798     Assert.assertEquals(request.getFlowVersion(), actualRequest.getFlowVersion());
799     Assert.assertTrue(
800         channelProvider.isHeaderSent(
801             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
802             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
803   }
804 
805   @Test
deployFlowExceptionTest()806   public void deployFlowExceptionTest() throws Exception {
807     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
808     mockEnvironments.addException(exception);
809 
810     try {
811       DeployFlowRequest request =
812           DeployFlowRequest.newBuilder()
813               .setEnvironment(
814                   EnvironmentName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[ENVIRONMENT]")
815                       .toString())
816               .setFlowVersion(
817                   VersionName.of("[PROJECT]", "[LOCATION]", "[AGENT]", "[FLOW]", "[VERSION]")
818                       .toString())
819               .build();
820       client.deployFlowAsync(request).get();
821       Assert.fail("No exception raised");
822     } catch (ExecutionException e) {
823       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
824       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
825       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
826     }
827   }
828 
829   @Test
listLocationsTest()830   public void listLocationsTest() throws Exception {
831     Location responsesElement = Location.newBuilder().build();
832     ListLocationsResponse expectedResponse =
833         ListLocationsResponse.newBuilder()
834             .setNextPageToken("")
835             .addAllLocations(Arrays.asList(responsesElement))
836             .build();
837     mockLocations.addResponse(expectedResponse);
838 
839     ListLocationsRequest request =
840         ListLocationsRequest.newBuilder()
841             .setName("name3373707")
842             .setFilter("filter-1274492040")
843             .setPageSize(883849137)
844             .setPageToken("pageToken873572522")
845             .build();
846 
847     ListLocationsPagedResponse pagedListResponse = client.listLocations(request);
848 
849     List<Location> resources = Lists.newArrayList(pagedListResponse.iterateAll());
850 
851     Assert.assertEquals(1, resources.size());
852     Assert.assertEquals(expectedResponse.getLocationsList().get(0), resources.get(0));
853 
854     List<AbstractMessage> actualRequests = mockLocations.getRequests();
855     Assert.assertEquals(1, actualRequests.size());
856     ListLocationsRequest actualRequest = ((ListLocationsRequest) actualRequests.get(0));
857 
858     Assert.assertEquals(request.getName(), actualRequest.getName());
859     Assert.assertEquals(request.getFilter(), actualRequest.getFilter());
860     Assert.assertEquals(request.getPageSize(), actualRequest.getPageSize());
861     Assert.assertEquals(request.getPageToken(), actualRequest.getPageToken());
862     Assert.assertTrue(
863         channelProvider.isHeaderSent(
864             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
865             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
866   }
867 
868   @Test
listLocationsExceptionTest()869   public void listLocationsExceptionTest() throws Exception {
870     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
871     mockLocations.addException(exception);
872 
873     try {
874       ListLocationsRequest request =
875           ListLocationsRequest.newBuilder()
876               .setName("name3373707")
877               .setFilter("filter-1274492040")
878               .setPageSize(883849137)
879               .setPageToken("pageToken873572522")
880               .build();
881       client.listLocations(request);
882       Assert.fail("No exception raised");
883     } catch (InvalidArgumentException e) {
884       // Expected exception.
885     }
886   }
887 
888   @Test
getLocationTest()889   public void getLocationTest() throws Exception {
890     Location expectedResponse =
891         Location.newBuilder()
892             .setName("name3373707")
893             .setLocationId("locationId1541836720")
894             .setDisplayName("displayName1714148973")
895             .putAllLabels(new HashMap<String, String>())
896             .setMetadata(Any.newBuilder().build())
897             .build();
898     mockLocations.addResponse(expectedResponse);
899 
900     GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
901 
902     Location actualResponse = client.getLocation(request);
903     Assert.assertEquals(expectedResponse, actualResponse);
904 
905     List<AbstractMessage> actualRequests = mockLocations.getRequests();
906     Assert.assertEquals(1, actualRequests.size());
907     GetLocationRequest actualRequest = ((GetLocationRequest) actualRequests.get(0));
908 
909     Assert.assertEquals(request.getName(), actualRequest.getName());
910     Assert.assertTrue(
911         channelProvider.isHeaderSent(
912             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
913             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
914   }
915 
916   @Test
getLocationExceptionTest()917   public void getLocationExceptionTest() throws Exception {
918     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
919     mockLocations.addException(exception);
920 
921     try {
922       GetLocationRequest request = GetLocationRequest.newBuilder().setName("name3373707").build();
923       client.getLocation(request);
924       Assert.fail("No exception raised");
925     } catch (InvalidArgumentException e) {
926       // Expected exception.
927     }
928   }
929 }
930