• 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.workflows.v1beta;
18 
19 import static com.google.cloud.workflows.v1beta.WorkflowsClient.ListWorkflowsPagedResponse;
20 
21 import com.google.api.gax.core.NoCredentialsProvider;
22 import com.google.api.gax.grpc.GaxGrpcProperties;
23 import com.google.api.gax.grpc.testing.LocalChannelProvider;
24 import com.google.api.gax.grpc.testing.MockGrpcService;
25 import com.google.api.gax.grpc.testing.MockServiceHelper;
26 import com.google.api.gax.rpc.ApiClientHeaderProvider;
27 import com.google.api.gax.rpc.InvalidArgumentException;
28 import com.google.api.gax.rpc.StatusCode;
29 import com.google.common.collect.Lists;
30 import com.google.longrunning.Operation;
31 import com.google.protobuf.AbstractMessage;
32 import com.google.protobuf.Any;
33 import com.google.protobuf.Empty;
34 import com.google.protobuf.FieldMask;
35 import com.google.protobuf.Timestamp;
36 import io.grpc.StatusRuntimeException;
37 import java.io.IOException;
38 import java.util.Arrays;
39 import java.util.HashMap;
40 import java.util.List;
41 import java.util.UUID;
42 import java.util.concurrent.ExecutionException;
43 import javax.annotation.Generated;
44 import org.junit.After;
45 import org.junit.AfterClass;
46 import org.junit.Assert;
47 import org.junit.Before;
48 import org.junit.BeforeClass;
49 import org.junit.Test;
50 
51 @Generated("by gapic-generator-java")
52 public class WorkflowsClientTest {
53   private static MockServiceHelper mockServiceHelper;
54   private static MockWorkflows mockWorkflows;
55   private LocalChannelProvider channelProvider;
56   private WorkflowsClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() {
60     mockWorkflows = new MockWorkflows();
61     mockServiceHelper =
62         new MockServiceHelper(
63             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockWorkflows));
64     mockServiceHelper.start();
65   }
66 
67   @AfterClass
stopServer()68   public static void stopServer() {
69     mockServiceHelper.stop();
70   }
71 
72   @Before
setUp()73   public void setUp() throws IOException {
74     mockServiceHelper.reset();
75     channelProvider = mockServiceHelper.createChannelProvider();
76     WorkflowsSettings settings =
77         WorkflowsSettings.newBuilder()
78             .setTransportChannelProvider(channelProvider)
79             .setCredentialsProvider(NoCredentialsProvider.create())
80             .build();
81     client = WorkflowsClient.create(settings);
82   }
83 
84   @After
tearDown()85   public void tearDown() throws Exception {
86     client.close();
87   }
88 
89   @Test
listWorkflowsTest()90   public void listWorkflowsTest() throws Exception {
91     Workflow responsesElement = Workflow.newBuilder().build();
92     ListWorkflowsResponse expectedResponse =
93         ListWorkflowsResponse.newBuilder()
94             .setNextPageToken("")
95             .addAllWorkflows(Arrays.asList(responsesElement))
96             .build();
97     mockWorkflows.addResponse(expectedResponse);
98 
99     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
100 
101     ListWorkflowsPagedResponse pagedListResponse = client.listWorkflows(parent);
102 
103     List<Workflow> resources = Lists.newArrayList(pagedListResponse.iterateAll());
104 
105     Assert.assertEquals(1, resources.size());
106     Assert.assertEquals(expectedResponse.getWorkflowsList().get(0), resources.get(0));
107 
108     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
109     Assert.assertEquals(1, actualRequests.size());
110     ListWorkflowsRequest actualRequest = ((ListWorkflowsRequest) actualRequests.get(0));
111 
112     Assert.assertEquals(parent.toString(), actualRequest.getParent());
113     Assert.assertTrue(
114         channelProvider.isHeaderSent(
115             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
116             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
117   }
118 
119   @Test
listWorkflowsExceptionTest()120   public void listWorkflowsExceptionTest() throws Exception {
121     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
122     mockWorkflows.addException(exception);
123 
124     try {
125       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
126       client.listWorkflows(parent);
127       Assert.fail("No exception raised");
128     } catch (InvalidArgumentException e) {
129       // Expected exception.
130     }
131   }
132 
133   @Test
listWorkflowsTest2()134   public void listWorkflowsTest2() throws Exception {
135     Workflow responsesElement = Workflow.newBuilder().build();
136     ListWorkflowsResponse expectedResponse =
137         ListWorkflowsResponse.newBuilder()
138             .setNextPageToken("")
139             .addAllWorkflows(Arrays.asList(responsesElement))
140             .build();
141     mockWorkflows.addResponse(expectedResponse);
142 
143     String parent = "parent-995424086";
144 
145     ListWorkflowsPagedResponse pagedListResponse = client.listWorkflows(parent);
146 
147     List<Workflow> resources = Lists.newArrayList(pagedListResponse.iterateAll());
148 
149     Assert.assertEquals(1, resources.size());
150     Assert.assertEquals(expectedResponse.getWorkflowsList().get(0), resources.get(0));
151 
152     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
153     Assert.assertEquals(1, actualRequests.size());
154     ListWorkflowsRequest actualRequest = ((ListWorkflowsRequest) actualRequests.get(0));
155 
156     Assert.assertEquals(parent, actualRequest.getParent());
157     Assert.assertTrue(
158         channelProvider.isHeaderSent(
159             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
160             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
161   }
162 
163   @Test
listWorkflowsExceptionTest2()164   public void listWorkflowsExceptionTest2() throws Exception {
165     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
166     mockWorkflows.addException(exception);
167 
168     try {
169       String parent = "parent-995424086";
170       client.listWorkflows(parent);
171       Assert.fail("No exception raised");
172     } catch (InvalidArgumentException e) {
173       // Expected exception.
174     }
175   }
176 
177   @Test
getWorkflowTest()178   public void getWorkflowTest() throws Exception {
179     Workflow expectedResponse =
180         Workflow.newBuilder()
181             .setName(WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]").toString())
182             .setDescription("description-1724546052")
183             .setRevisionId("revisionId-1507445162")
184             .setCreateTime(Timestamp.newBuilder().build())
185             .setUpdateTime(Timestamp.newBuilder().build())
186             .setRevisionCreateTime(Timestamp.newBuilder().build())
187             .putAllLabels(new HashMap<String, String>())
188             .setServiceAccount("serviceAccount1079137720")
189             .build();
190     mockWorkflows.addResponse(expectedResponse);
191 
192     WorkflowName name = WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
193 
194     Workflow actualResponse = client.getWorkflow(name);
195     Assert.assertEquals(expectedResponse, actualResponse);
196 
197     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
198     Assert.assertEquals(1, actualRequests.size());
199     GetWorkflowRequest actualRequest = ((GetWorkflowRequest) actualRequests.get(0));
200 
201     Assert.assertEquals(name.toString(), actualRequest.getName());
202     Assert.assertTrue(
203         channelProvider.isHeaderSent(
204             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
205             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
206   }
207 
208   @Test
getWorkflowExceptionTest()209   public void getWorkflowExceptionTest() throws Exception {
210     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
211     mockWorkflows.addException(exception);
212 
213     try {
214       WorkflowName name = WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
215       client.getWorkflow(name);
216       Assert.fail("No exception raised");
217     } catch (InvalidArgumentException e) {
218       // Expected exception.
219     }
220   }
221 
222   @Test
getWorkflowTest2()223   public void getWorkflowTest2() throws Exception {
224     Workflow expectedResponse =
225         Workflow.newBuilder()
226             .setName(WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]").toString())
227             .setDescription("description-1724546052")
228             .setRevisionId("revisionId-1507445162")
229             .setCreateTime(Timestamp.newBuilder().build())
230             .setUpdateTime(Timestamp.newBuilder().build())
231             .setRevisionCreateTime(Timestamp.newBuilder().build())
232             .putAllLabels(new HashMap<String, String>())
233             .setServiceAccount("serviceAccount1079137720")
234             .build();
235     mockWorkflows.addResponse(expectedResponse);
236 
237     String name = "name3373707";
238 
239     Workflow actualResponse = client.getWorkflow(name);
240     Assert.assertEquals(expectedResponse, actualResponse);
241 
242     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
243     Assert.assertEquals(1, actualRequests.size());
244     GetWorkflowRequest actualRequest = ((GetWorkflowRequest) actualRequests.get(0));
245 
246     Assert.assertEquals(name, actualRequest.getName());
247     Assert.assertTrue(
248         channelProvider.isHeaderSent(
249             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
250             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
251   }
252 
253   @Test
getWorkflowExceptionTest2()254   public void getWorkflowExceptionTest2() throws Exception {
255     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
256     mockWorkflows.addException(exception);
257 
258     try {
259       String name = "name3373707";
260       client.getWorkflow(name);
261       Assert.fail("No exception raised");
262     } catch (InvalidArgumentException e) {
263       // Expected exception.
264     }
265   }
266 
267   @Test
createWorkflowTest()268   public void createWorkflowTest() throws Exception {
269     Workflow expectedResponse =
270         Workflow.newBuilder()
271             .setName(WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]").toString())
272             .setDescription("description-1724546052")
273             .setRevisionId("revisionId-1507445162")
274             .setCreateTime(Timestamp.newBuilder().build())
275             .setUpdateTime(Timestamp.newBuilder().build())
276             .setRevisionCreateTime(Timestamp.newBuilder().build())
277             .putAllLabels(new HashMap<String, String>())
278             .setServiceAccount("serviceAccount1079137720")
279             .build();
280     Operation resultOperation =
281         Operation.newBuilder()
282             .setName("createWorkflowTest")
283             .setDone(true)
284             .setResponse(Any.pack(expectedResponse))
285             .build();
286     mockWorkflows.addResponse(resultOperation);
287 
288     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
289     Workflow workflow = Workflow.newBuilder().build();
290     String workflowId = "workflowId-360387270";
291 
292     Workflow actualResponse = client.createWorkflowAsync(parent, workflow, workflowId).get();
293     Assert.assertEquals(expectedResponse, actualResponse);
294 
295     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
296     Assert.assertEquals(1, actualRequests.size());
297     CreateWorkflowRequest actualRequest = ((CreateWorkflowRequest) actualRequests.get(0));
298 
299     Assert.assertEquals(parent.toString(), actualRequest.getParent());
300     Assert.assertEquals(workflow, actualRequest.getWorkflow());
301     Assert.assertEquals(workflowId, actualRequest.getWorkflowId());
302     Assert.assertTrue(
303         channelProvider.isHeaderSent(
304             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
305             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
306   }
307 
308   @Test
createWorkflowExceptionTest()309   public void createWorkflowExceptionTest() throws Exception {
310     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
311     mockWorkflows.addException(exception);
312 
313     try {
314       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
315       Workflow workflow = Workflow.newBuilder().build();
316       String workflowId = "workflowId-360387270";
317       client.createWorkflowAsync(parent, workflow, workflowId).get();
318       Assert.fail("No exception raised");
319     } catch (ExecutionException e) {
320       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
321       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
322       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
323     }
324   }
325 
326   @Test
createWorkflowTest2()327   public void createWorkflowTest2() throws Exception {
328     Workflow expectedResponse =
329         Workflow.newBuilder()
330             .setName(WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]").toString())
331             .setDescription("description-1724546052")
332             .setRevisionId("revisionId-1507445162")
333             .setCreateTime(Timestamp.newBuilder().build())
334             .setUpdateTime(Timestamp.newBuilder().build())
335             .setRevisionCreateTime(Timestamp.newBuilder().build())
336             .putAllLabels(new HashMap<String, String>())
337             .setServiceAccount("serviceAccount1079137720")
338             .build();
339     Operation resultOperation =
340         Operation.newBuilder()
341             .setName("createWorkflowTest")
342             .setDone(true)
343             .setResponse(Any.pack(expectedResponse))
344             .build();
345     mockWorkflows.addResponse(resultOperation);
346 
347     String parent = "parent-995424086";
348     Workflow workflow = Workflow.newBuilder().build();
349     String workflowId = "workflowId-360387270";
350 
351     Workflow actualResponse = client.createWorkflowAsync(parent, workflow, workflowId).get();
352     Assert.assertEquals(expectedResponse, actualResponse);
353 
354     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
355     Assert.assertEquals(1, actualRequests.size());
356     CreateWorkflowRequest actualRequest = ((CreateWorkflowRequest) actualRequests.get(0));
357 
358     Assert.assertEquals(parent, actualRequest.getParent());
359     Assert.assertEquals(workflow, actualRequest.getWorkflow());
360     Assert.assertEquals(workflowId, actualRequest.getWorkflowId());
361     Assert.assertTrue(
362         channelProvider.isHeaderSent(
363             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
364             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
365   }
366 
367   @Test
createWorkflowExceptionTest2()368   public void createWorkflowExceptionTest2() throws Exception {
369     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
370     mockWorkflows.addException(exception);
371 
372     try {
373       String parent = "parent-995424086";
374       Workflow workflow = Workflow.newBuilder().build();
375       String workflowId = "workflowId-360387270";
376       client.createWorkflowAsync(parent, workflow, workflowId).get();
377       Assert.fail("No exception raised");
378     } catch (ExecutionException e) {
379       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
380       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
381       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
382     }
383   }
384 
385   @Test
deleteWorkflowTest()386   public void deleteWorkflowTest() throws Exception {
387     Empty expectedResponse = Empty.newBuilder().build();
388     Operation resultOperation =
389         Operation.newBuilder()
390             .setName("deleteWorkflowTest")
391             .setDone(true)
392             .setResponse(Any.pack(expectedResponse))
393             .build();
394     mockWorkflows.addResponse(resultOperation);
395 
396     WorkflowName name = WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
397 
398     client.deleteWorkflowAsync(name).get();
399 
400     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
401     Assert.assertEquals(1, actualRequests.size());
402     DeleteWorkflowRequest actualRequest = ((DeleteWorkflowRequest) actualRequests.get(0));
403 
404     Assert.assertEquals(name.toString(), actualRequest.getName());
405     Assert.assertTrue(
406         channelProvider.isHeaderSent(
407             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
408             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
409   }
410 
411   @Test
deleteWorkflowExceptionTest()412   public void deleteWorkflowExceptionTest() throws Exception {
413     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
414     mockWorkflows.addException(exception);
415 
416     try {
417       WorkflowName name = WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]");
418       client.deleteWorkflowAsync(name).get();
419       Assert.fail("No exception raised");
420     } catch (ExecutionException e) {
421       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
422       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
423       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
424     }
425   }
426 
427   @Test
deleteWorkflowTest2()428   public void deleteWorkflowTest2() throws Exception {
429     Empty expectedResponse = Empty.newBuilder().build();
430     Operation resultOperation =
431         Operation.newBuilder()
432             .setName("deleteWorkflowTest")
433             .setDone(true)
434             .setResponse(Any.pack(expectedResponse))
435             .build();
436     mockWorkflows.addResponse(resultOperation);
437 
438     String name = "name3373707";
439 
440     client.deleteWorkflowAsync(name).get();
441 
442     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
443     Assert.assertEquals(1, actualRequests.size());
444     DeleteWorkflowRequest actualRequest = ((DeleteWorkflowRequest) actualRequests.get(0));
445 
446     Assert.assertEquals(name, actualRequest.getName());
447     Assert.assertTrue(
448         channelProvider.isHeaderSent(
449             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
450             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
451   }
452 
453   @Test
deleteWorkflowExceptionTest2()454   public void deleteWorkflowExceptionTest2() throws Exception {
455     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
456     mockWorkflows.addException(exception);
457 
458     try {
459       String name = "name3373707";
460       client.deleteWorkflowAsync(name).get();
461       Assert.fail("No exception raised");
462     } catch (ExecutionException e) {
463       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
464       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
465       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
466     }
467   }
468 
469   @Test
updateWorkflowTest()470   public void updateWorkflowTest() throws Exception {
471     Workflow expectedResponse =
472         Workflow.newBuilder()
473             .setName(WorkflowName.of("[PROJECT]", "[LOCATION]", "[WORKFLOW]").toString())
474             .setDescription("description-1724546052")
475             .setRevisionId("revisionId-1507445162")
476             .setCreateTime(Timestamp.newBuilder().build())
477             .setUpdateTime(Timestamp.newBuilder().build())
478             .setRevisionCreateTime(Timestamp.newBuilder().build())
479             .putAllLabels(new HashMap<String, String>())
480             .setServiceAccount("serviceAccount1079137720")
481             .build();
482     Operation resultOperation =
483         Operation.newBuilder()
484             .setName("updateWorkflowTest")
485             .setDone(true)
486             .setResponse(Any.pack(expectedResponse))
487             .build();
488     mockWorkflows.addResponse(resultOperation);
489 
490     Workflow workflow = Workflow.newBuilder().build();
491     FieldMask updateMask = FieldMask.newBuilder().build();
492 
493     Workflow actualResponse = client.updateWorkflowAsync(workflow, updateMask).get();
494     Assert.assertEquals(expectedResponse, actualResponse);
495 
496     List<AbstractMessage> actualRequests = mockWorkflows.getRequests();
497     Assert.assertEquals(1, actualRequests.size());
498     UpdateWorkflowRequest actualRequest = ((UpdateWorkflowRequest) actualRequests.get(0));
499 
500     Assert.assertEquals(workflow, actualRequest.getWorkflow());
501     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
502     Assert.assertTrue(
503         channelProvider.isHeaderSent(
504             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
505             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
506   }
507 
508   @Test
updateWorkflowExceptionTest()509   public void updateWorkflowExceptionTest() throws Exception {
510     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
511     mockWorkflows.addException(exception);
512 
513     try {
514       Workflow workflow = Workflow.newBuilder().build();
515       FieldMask updateMask = FieldMask.newBuilder().build();
516       client.updateWorkflowAsync(workflow, updateMask).get();
517       Assert.fail("No exception raised");
518     } catch (ExecutionException e) {
519       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
520       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
521       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
522     }
523   }
524 }
525