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