• 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.gaming.v1beta;
18 
19 import static com.google.cloud.gaming.v1beta.GameServerClustersServiceClient.ListGameServerClustersPagedResponse;
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 GameServerClustersServiceClientTest {
53   private static MockGameServerClustersService mockGameServerClustersService;
54   private static MockServiceHelper mockServiceHelper;
55   private LocalChannelProvider channelProvider;
56   private GameServerClustersServiceClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() {
60     mockGameServerClustersService = new MockGameServerClustersService();
61     mockServiceHelper =
62         new MockServiceHelper(
63             UUID.randomUUID().toString(),
64             Arrays.<MockGrpcService>asList(mockGameServerClustersService));
65     mockServiceHelper.start();
66   }
67 
68   @AfterClass
stopServer()69   public static void stopServer() {
70     mockServiceHelper.stop();
71   }
72 
73   @Before
setUp()74   public void setUp() throws IOException {
75     mockServiceHelper.reset();
76     channelProvider = mockServiceHelper.createChannelProvider();
77     GameServerClustersServiceSettings settings =
78         GameServerClustersServiceSettings.newBuilder()
79             .setTransportChannelProvider(channelProvider)
80             .setCredentialsProvider(NoCredentialsProvider.create())
81             .build();
82     client = GameServerClustersServiceClient.create(settings);
83   }
84 
85   @After
tearDown()86   public void tearDown() throws Exception {
87     client.close();
88   }
89 
90   @Test
listGameServerClustersTest()91   public void listGameServerClustersTest() throws Exception {
92     GameServerCluster responsesElement = GameServerCluster.newBuilder().build();
93     ListGameServerClustersResponse expectedResponse =
94         ListGameServerClustersResponse.newBuilder()
95             .setNextPageToken("")
96             .addAllGameServerClusters(Arrays.asList(responsesElement))
97             .build();
98     mockGameServerClustersService.addResponse(expectedResponse);
99 
100     RealmName parent = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
101 
102     ListGameServerClustersPagedResponse pagedListResponse = client.listGameServerClusters(parent);
103 
104     List<GameServerCluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
105 
106     Assert.assertEquals(1, resources.size());
107     Assert.assertEquals(expectedResponse.getGameServerClustersList().get(0), resources.get(0));
108 
109     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
110     Assert.assertEquals(1, actualRequests.size());
111     ListGameServerClustersRequest actualRequest =
112         ((ListGameServerClustersRequest) actualRequests.get(0));
113 
114     Assert.assertEquals(parent.toString(), actualRequest.getParent());
115     Assert.assertTrue(
116         channelProvider.isHeaderSent(
117             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
118             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
119   }
120 
121   @Test
listGameServerClustersExceptionTest()122   public void listGameServerClustersExceptionTest() throws Exception {
123     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
124     mockGameServerClustersService.addException(exception);
125 
126     try {
127       RealmName parent = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
128       client.listGameServerClusters(parent);
129       Assert.fail("No exception raised");
130     } catch (InvalidArgumentException e) {
131       // Expected exception.
132     }
133   }
134 
135   @Test
listGameServerClustersTest2()136   public void listGameServerClustersTest2() throws Exception {
137     GameServerCluster responsesElement = GameServerCluster.newBuilder().build();
138     ListGameServerClustersResponse expectedResponse =
139         ListGameServerClustersResponse.newBuilder()
140             .setNextPageToken("")
141             .addAllGameServerClusters(Arrays.asList(responsesElement))
142             .build();
143     mockGameServerClustersService.addResponse(expectedResponse);
144 
145     String parent = "parent-995424086";
146 
147     ListGameServerClustersPagedResponse pagedListResponse = client.listGameServerClusters(parent);
148 
149     List<GameServerCluster> resources = Lists.newArrayList(pagedListResponse.iterateAll());
150 
151     Assert.assertEquals(1, resources.size());
152     Assert.assertEquals(expectedResponse.getGameServerClustersList().get(0), resources.get(0));
153 
154     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
155     Assert.assertEquals(1, actualRequests.size());
156     ListGameServerClustersRequest actualRequest =
157         ((ListGameServerClustersRequest) actualRequests.get(0));
158 
159     Assert.assertEquals(parent, actualRequest.getParent());
160     Assert.assertTrue(
161         channelProvider.isHeaderSent(
162             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
163             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
164   }
165 
166   @Test
listGameServerClustersExceptionTest2()167   public void listGameServerClustersExceptionTest2() throws Exception {
168     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
169     mockGameServerClustersService.addException(exception);
170 
171     try {
172       String parent = "parent-995424086";
173       client.listGameServerClusters(parent);
174       Assert.fail("No exception raised");
175     } catch (InvalidArgumentException e) {
176       // Expected exception.
177     }
178   }
179 
180   @Test
getGameServerClusterTest()181   public void getGameServerClusterTest() throws Exception {
182     GameServerCluster expectedResponse =
183         GameServerCluster.newBuilder()
184             .setName(
185                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
186                     .toString())
187             .setCreateTime(Timestamp.newBuilder().build())
188             .setUpdateTime(Timestamp.newBuilder().build())
189             .putAllLabels(new HashMap<String, String>())
190             .setConnectionInfo(GameServerClusterConnectionInfo.newBuilder().build())
191             .setEtag("etag3123477")
192             .setDescription("description-1724546052")
193             .build();
194     mockGameServerClustersService.addResponse(expectedResponse);
195 
196     GameServerClusterName name =
197         GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]");
198 
199     GameServerCluster actualResponse = client.getGameServerCluster(name);
200     Assert.assertEquals(expectedResponse, actualResponse);
201 
202     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
203     Assert.assertEquals(1, actualRequests.size());
204     GetGameServerClusterRequest actualRequest =
205         ((GetGameServerClusterRequest) actualRequests.get(0));
206 
207     Assert.assertEquals(name.toString(), actualRequest.getName());
208     Assert.assertTrue(
209         channelProvider.isHeaderSent(
210             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
211             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
212   }
213 
214   @Test
getGameServerClusterExceptionTest()215   public void getGameServerClusterExceptionTest() throws Exception {
216     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
217     mockGameServerClustersService.addException(exception);
218 
219     try {
220       GameServerClusterName name =
221           GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]");
222       client.getGameServerCluster(name);
223       Assert.fail("No exception raised");
224     } catch (InvalidArgumentException e) {
225       // Expected exception.
226     }
227   }
228 
229   @Test
getGameServerClusterTest2()230   public void getGameServerClusterTest2() throws Exception {
231     GameServerCluster expectedResponse =
232         GameServerCluster.newBuilder()
233             .setName(
234                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
235                     .toString())
236             .setCreateTime(Timestamp.newBuilder().build())
237             .setUpdateTime(Timestamp.newBuilder().build())
238             .putAllLabels(new HashMap<String, String>())
239             .setConnectionInfo(GameServerClusterConnectionInfo.newBuilder().build())
240             .setEtag("etag3123477")
241             .setDescription("description-1724546052")
242             .build();
243     mockGameServerClustersService.addResponse(expectedResponse);
244 
245     String name = "name3373707";
246 
247     GameServerCluster actualResponse = client.getGameServerCluster(name);
248     Assert.assertEquals(expectedResponse, actualResponse);
249 
250     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
251     Assert.assertEquals(1, actualRequests.size());
252     GetGameServerClusterRequest actualRequest =
253         ((GetGameServerClusterRequest) actualRequests.get(0));
254 
255     Assert.assertEquals(name, actualRequest.getName());
256     Assert.assertTrue(
257         channelProvider.isHeaderSent(
258             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
259             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
260   }
261 
262   @Test
getGameServerClusterExceptionTest2()263   public void getGameServerClusterExceptionTest2() throws Exception {
264     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
265     mockGameServerClustersService.addException(exception);
266 
267     try {
268       String name = "name3373707";
269       client.getGameServerCluster(name);
270       Assert.fail("No exception raised");
271     } catch (InvalidArgumentException e) {
272       // Expected exception.
273     }
274   }
275 
276   @Test
createGameServerClusterTest()277   public void createGameServerClusterTest() throws Exception {
278     GameServerCluster expectedResponse =
279         GameServerCluster.newBuilder()
280             .setName(
281                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
282                     .toString())
283             .setCreateTime(Timestamp.newBuilder().build())
284             .setUpdateTime(Timestamp.newBuilder().build())
285             .putAllLabels(new HashMap<String, String>())
286             .setConnectionInfo(GameServerClusterConnectionInfo.newBuilder().build())
287             .setEtag("etag3123477")
288             .setDescription("description-1724546052")
289             .build();
290     Operation resultOperation =
291         Operation.newBuilder()
292             .setName("createGameServerClusterTest")
293             .setDone(true)
294             .setResponse(Any.pack(expectedResponse))
295             .build();
296     mockGameServerClustersService.addResponse(resultOperation);
297 
298     RealmName parent = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
299     GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
300     String gameServerClusterId = "gameServerClusterId-1301104032";
301 
302     GameServerCluster actualResponse =
303         client.createGameServerClusterAsync(parent, gameServerCluster, gameServerClusterId).get();
304     Assert.assertEquals(expectedResponse, actualResponse);
305 
306     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
307     Assert.assertEquals(1, actualRequests.size());
308     CreateGameServerClusterRequest actualRequest =
309         ((CreateGameServerClusterRequest) actualRequests.get(0));
310 
311     Assert.assertEquals(parent.toString(), actualRequest.getParent());
312     Assert.assertEquals(gameServerCluster, actualRequest.getGameServerCluster());
313     Assert.assertEquals(gameServerClusterId, actualRequest.getGameServerClusterId());
314     Assert.assertTrue(
315         channelProvider.isHeaderSent(
316             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
317             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
318   }
319 
320   @Test
createGameServerClusterExceptionTest()321   public void createGameServerClusterExceptionTest() throws Exception {
322     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
323     mockGameServerClustersService.addException(exception);
324 
325     try {
326       RealmName parent = RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]");
327       GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
328       String gameServerClusterId = "gameServerClusterId-1301104032";
329       client.createGameServerClusterAsync(parent, gameServerCluster, gameServerClusterId).get();
330       Assert.fail("No exception raised");
331     } catch (ExecutionException e) {
332       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
333       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
334       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
335     }
336   }
337 
338   @Test
createGameServerClusterTest2()339   public void createGameServerClusterTest2() throws Exception {
340     GameServerCluster expectedResponse =
341         GameServerCluster.newBuilder()
342             .setName(
343                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
344                     .toString())
345             .setCreateTime(Timestamp.newBuilder().build())
346             .setUpdateTime(Timestamp.newBuilder().build())
347             .putAllLabels(new HashMap<String, String>())
348             .setConnectionInfo(GameServerClusterConnectionInfo.newBuilder().build())
349             .setEtag("etag3123477")
350             .setDescription("description-1724546052")
351             .build();
352     Operation resultOperation =
353         Operation.newBuilder()
354             .setName("createGameServerClusterTest")
355             .setDone(true)
356             .setResponse(Any.pack(expectedResponse))
357             .build();
358     mockGameServerClustersService.addResponse(resultOperation);
359 
360     String parent = "parent-995424086";
361     GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
362     String gameServerClusterId = "gameServerClusterId-1301104032";
363 
364     GameServerCluster actualResponse =
365         client.createGameServerClusterAsync(parent, gameServerCluster, gameServerClusterId).get();
366     Assert.assertEquals(expectedResponse, actualResponse);
367 
368     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
369     Assert.assertEquals(1, actualRequests.size());
370     CreateGameServerClusterRequest actualRequest =
371         ((CreateGameServerClusterRequest) actualRequests.get(0));
372 
373     Assert.assertEquals(parent, actualRequest.getParent());
374     Assert.assertEquals(gameServerCluster, actualRequest.getGameServerCluster());
375     Assert.assertEquals(gameServerClusterId, actualRequest.getGameServerClusterId());
376     Assert.assertTrue(
377         channelProvider.isHeaderSent(
378             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
379             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
380   }
381 
382   @Test
createGameServerClusterExceptionTest2()383   public void createGameServerClusterExceptionTest2() throws Exception {
384     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
385     mockGameServerClustersService.addException(exception);
386 
387     try {
388       String parent = "parent-995424086";
389       GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
390       String gameServerClusterId = "gameServerClusterId-1301104032";
391       client.createGameServerClusterAsync(parent, gameServerCluster, gameServerClusterId).get();
392       Assert.fail("No exception raised");
393     } catch (ExecutionException e) {
394       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
395       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
396       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
397     }
398   }
399 
400   @Test
previewCreateGameServerClusterTest()401   public void previewCreateGameServerClusterTest() throws Exception {
402     PreviewCreateGameServerClusterResponse expectedResponse =
403         PreviewCreateGameServerClusterResponse.newBuilder()
404             .setEtag("etag3123477")
405             .setTargetState(TargetState.newBuilder().build())
406             .build();
407     mockGameServerClustersService.addResponse(expectedResponse);
408 
409     PreviewCreateGameServerClusterRequest request =
410         PreviewCreateGameServerClusterRequest.newBuilder()
411             .setParent(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
412             .setGameServerClusterId("gameServerClusterId-1301104032")
413             .setGameServerCluster(GameServerCluster.newBuilder().build())
414             .setPreviewTime(Timestamp.newBuilder().build())
415             .build();
416 
417     PreviewCreateGameServerClusterResponse actualResponse =
418         client.previewCreateGameServerCluster(request);
419     Assert.assertEquals(expectedResponse, actualResponse);
420 
421     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
422     Assert.assertEquals(1, actualRequests.size());
423     PreviewCreateGameServerClusterRequest actualRequest =
424         ((PreviewCreateGameServerClusterRequest) actualRequests.get(0));
425 
426     Assert.assertEquals(request.getParent(), actualRequest.getParent());
427     Assert.assertEquals(request.getGameServerClusterId(), actualRequest.getGameServerClusterId());
428     Assert.assertEquals(request.getGameServerCluster(), actualRequest.getGameServerCluster());
429     Assert.assertEquals(request.getPreviewTime(), actualRequest.getPreviewTime());
430     Assert.assertTrue(
431         channelProvider.isHeaderSent(
432             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
433             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
434   }
435 
436   @Test
previewCreateGameServerClusterExceptionTest()437   public void previewCreateGameServerClusterExceptionTest() throws Exception {
438     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
439     mockGameServerClustersService.addException(exception);
440 
441     try {
442       PreviewCreateGameServerClusterRequest request =
443           PreviewCreateGameServerClusterRequest.newBuilder()
444               .setParent(RealmName.of("[PROJECT]", "[LOCATION]", "[REALM]").toString())
445               .setGameServerClusterId("gameServerClusterId-1301104032")
446               .setGameServerCluster(GameServerCluster.newBuilder().build())
447               .setPreviewTime(Timestamp.newBuilder().build())
448               .build();
449       client.previewCreateGameServerCluster(request);
450       Assert.fail("No exception raised");
451     } catch (InvalidArgumentException e) {
452       // Expected exception.
453     }
454   }
455 
456   @Test
deleteGameServerClusterTest()457   public void deleteGameServerClusterTest() throws Exception {
458     Empty expectedResponse = Empty.newBuilder().build();
459     Operation resultOperation =
460         Operation.newBuilder()
461             .setName("deleteGameServerClusterTest")
462             .setDone(true)
463             .setResponse(Any.pack(expectedResponse))
464             .build();
465     mockGameServerClustersService.addResponse(resultOperation);
466 
467     GameServerClusterName name =
468         GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]");
469 
470     client.deleteGameServerClusterAsync(name).get();
471 
472     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
473     Assert.assertEquals(1, actualRequests.size());
474     DeleteGameServerClusterRequest actualRequest =
475         ((DeleteGameServerClusterRequest) actualRequests.get(0));
476 
477     Assert.assertEquals(name.toString(), actualRequest.getName());
478     Assert.assertTrue(
479         channelProvider.isHeaderSent(
480             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
481             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
482   }
483 
484   @Test
deleteGameServerClusterExceptionTest()485   public void deleteGameServerClusterExceptionTest() throws Exception {
486     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
487     mockGameServerClustersService.addException(exception);
488 
489     try {
490       GameServerClusterName name =
491           GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]");
492       client.deleteGameServerClusterAsync(name).get();
493       Assert.fail("No exception raised");
494     } catch (ExecutionException e) {
495       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
496       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
497       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
498     }
499   }
500 
501   @Test
deleteGameServerClusterTest2()502   public void deleteGameServerClusterTest2() throws Exception {
503     Empty expectedResponse = Empty.newBuilder().build();
504     Operation resultOperation =
505         Operation.newBuilder()
506             .setName("deleteGameServerClusterTest")
507             .setDone(true)
508             .setResponse(Any.pack(expectedResponse))
509             .build();
510     mockGameServerClustersService.addResponse(resultOperation);
511 
512     String name = "name3373707";
513 
514     client.deleteGameServerClusterAsync(name).get();
515 
516     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
517     Assert.assertEquals(1, actualRequests.size());
518     DeleteGameServerClusterRequest actualRequest =
519         ((DeleteGameServerClusterRequest) actualRequests.get(0));
520 
521     Assert.assertEquals(name, actualRequest.getName());
522     Assert.assertTrue(
523         channelProvider.isHeaderSent(
524             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
525             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
526   }
527 
528   @Test
deleteGameServerClusterExceptionTest2()529   public void deleteGameServerClusterExceptionTest2() throws Exception {
530     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
531     mockGameServerClustersService.addException(exception);
532 
533     try {
534       String name = "name3373707";
535       client.deleteGameServerClusterAsync(name).get();
536       Assert.fail("No exception raised");
537     } catch (ExecutionException e) {
538       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
539       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
540       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
541     }
542   }
543 
544   @Test
previewDeleteGameServerClusterTest()545   public void previewDeleteGameServerClusterTest() throws Exception {
546     PreviewDeleteGameServerClusterResponse expectedResponse =
547         PreviewDeleteGameServerClusterResponse.newBuilder()
548             .setEtag("etag3123477")
549             .setTargetState(TargetState.newBuilder().build())
550             .build();
551     mockGameServerClustersService.addResponse(expectedResponse);
552 
553     PreviewDeleteGameServerClusterRequest request =
554         PreviewDeleteGameServerClusterRequest.newBuilder()
555             .setName(
556                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
557                     .toString())
558             .setPreviewTime(Timestamp.newBuilder().build())
559             .build();
560 
561     PreviewDeleteGameServerClusterResponse actualResponse =
562         client.previewDeleteGameServerCluster(request);
563     Assert.assertEquals(expectedResponse, actualResponse);
564 
565     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
566     Assert.assertEquals(1, actualRequests.size());
567     PreviewDeleteGameServerClusterRequest actualRequest =
568         ((PreviewDeleteGameServerClusterRequest) actualRequests.get(0));
569 
570     Assert.assertEquals(request.getName(), actualRequest.getName());
571     Assert.assertEquals(request.getPreviewTime(), actualRequest.getPreviewTime());
572     Assert.assertTrue(
573         channelProvider.isHeaderSent(
574             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
575             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
576   }
577 
578   @Test
previewDeleteGameServerClusterExceptionTest()579   public void previewDeleteGameServerClusterExceptionTest() throws Exception {
580     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
581     mockGameServerClustersService.addException(exception);
582 
583     try {
584       PreviewDeleteGameServerClusterRequest request =
585           PreviewDeleteGameServerClusterRequest.newBuilder()
586               .setName(
587                   GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
588                       .toString())
589               .setPreviewTime(Timestamp.newBuilder().build())
590               .build();
591       client.previewDeleteGameServerCluster(request);
592       Assert.fail("No exception raised");
593     } catch (InvalidArgumentException e) {
594       // Expected exception.
595     }
596   }
597 
598   @Test
updateGameServerClusterTest()599   public void updateGameServerClusterTest() throws Exception {
600     GameServerCluster expectedResponse =
601         GameServerCluster.newBuilder()
602             .setName(
603                 GameServerClusterName.of("[PROJECT]", "[LOCATION]", "[REALM]", "[CLUSTER]")
604                     .toString())
605             .setCreateTime(Timestamp.newBuilder().build())
606             .setUpdateTime(Timestamp.newBuilder().build())
607             .putAllLabels(new HashMap<String, String>())
608             .setConnectionInfo(GameServerClusterConnectionInfo.newBuilder().build())
609             .setEtag("etag3123477")
610             .setDescription("description-1724546052")
611             .build();
612     Operation resultOperation =
613         Operation.newBuilder()
614             .setName("updateGameServerClusterTest")
615             .setDone(true)
616             .setResponse(Any.pack(expectedResponse))
617             .build();
618     mockGameServerClustersService.addResponse(resultOperation);
619 
620     GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
621     FieldMask updateMask = FieldMask.newBuilder().build();
622 
623     GameServerCluster actualResponse =
624         client.updateGameServerClusterAsync(gameServerCluster, updateMask).get();
625     Assert.assertEquals(expectedResponse, actualResponse);
626 
627     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
628     Assert.assertEquals(1, actualRequests.size());
629     UpdateGameServerClusterRequest actualRequest =
630         ((UpdateGameServerClusterRequest) actualRequests.get(0));
631 
632     Assert.assertEquals(gameServerCluster, actualRequest.getGameServerCluster());
633     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
634     Assert.assertTrue(
635         channelProvider.isHeaderSent(
636             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
637             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
638   }
639 
640   @Test
updateGameServerClusterExceptionTest()641   public void updateGameServerClusterExceptionTest() throws Exception {
642     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
643     mockGameServerClustersService.addException(exception);
644 
645     try {
646       GameServerCluster gameServerCluster = GameServerCluster.newBuilder().build();
647       FieldMask updateMask = FieldMask.newBuilder().build();
648       client.updateGameServerClusterAsync(gameServerCluster, updateMask).get();
649       Assert.fail("No exception raised");
650     } catch (ExecutionException e) {
651       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
652       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
653       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
654     }
655   }
656 
657   @Test
previewUpdateGameServerClusterTest()658   public void previewUpdateGameServerClusterTest() throws Exception {
659     PreviewUpdateGameServerClusterResponse expectedResponse =
660         PreviewUpdateGameServerClusterResponse.newBuilder()
661             .setEtag("etag3123477")
662             .setTargetState(TargetState.newBuilder().build())
663             .build();
664     mockGameServerClustersService.addResponse(expectedResponse);
665 
666     PreviewUpdateGameServerClusterRequest request =
667         PreviewUpdateGameServerClusterRequest.newBuilder()
668             .setGameServerCluster(GameServerCluster.newBuilder().build())
669             .setUpdateMask(FieldMask.newBuilder().build())
670             .setPreviewTime(Timestamp.newBuilder().build())
671             .build();
672 
673     PreviewUpdateGameServerClusterResponse actualResponse =
674         client.previewUpdateGameServerCluster(request);
675     Assert.assertEquals(expectedResponse, actualResponse);
676 
677     List<AbstractMessage> actualRequests = mockGameServerClustersService.getRequests();
678     Assert.assertEquals(1, actualRequests.size());
679     PreviewUpdateGameServerClusterRequest actualRequest =
680         ((PreviewUpdateGameServerClusterRequest) actualRequests.get(0));
681 
682     Assert.assertEquals(request.getGameServerCluster(), actualRequest.getGameServerCluster());
683     Assert.assertEquals(request.getUpdateMask(), actualRequest.getUpdateMask());
684     Assert.assertEquals(request.getPreviewTime(), actualRequest.getPreviewTime());
685     Assert.assertTrue(
686         channelProvider.isHeaderSent(
687             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
688             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
689   }
690 
691   @Test
previewUpdateGameServerClusterExceptionTest()692   public void previewUpdateGameServerClusterExceptionTest() throws Exception {
693     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
694     mockGameServerClustersService.addException(exception);
695 
696     try {
697       PreviewUpdateGameServerClusterRequest request =
698           PreviewUpdateGameServerClusterRequest.newBuilder()
699               .setGameServerCluster(GameServerCluster.newBuilder().build())
700               .setUpdateMask(FieldMask.newBuilder().build())
701               .setPreviewTime(Timestamp.newBuilder().build())
702               .build();
703       client.previewUpdateGameServerCluster(request);
704       Assert.fail("No exception raised");
705     } catch (InvalidArgumentException e) {
706       // Expected exception.
707     }
708   }
709 }
710