• 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.domains.v1;
18 
19 import static com.google.cloud.domains.v1.DomainsClient.ListRegistrationsPagedResponse;
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 com.google.type.Money;
37 import io.grpc.StatusRuntimeException;
38 import java.io.IOException;
39 import java.util.ArrayList;
40 import java.util.Arrays;
41 import java.util.HashMap;
42 import java.util.List;
43 import java.util.UUID;
44 import java.util.concurrent.ExecutionException;
45 import javax.annotation.Generated;
46 import org.junit.After;
47 import org.junit.AfterClass;
48 import org.junit.Assert;
49 import org.junit.Before;
50 import org.junit.BeforeClass;
51 import org.junit.Test;
52 
53 @Generated("by gapic-generator-java")
54 public class DomainsClientTest {
55   private static MockDomains mockDomains;
56   private static MockServiceHelper mockServiceHelper;
57   private LocalChannelProvider channelProvider;
58   private DomainsClient client;
59 
60   @BeforeClass
startStaticServer()61   public static void startStaticServer() {
62     mockDomains = new MockDomains();
63     mockServiceHelper =
64         new MockServiceHelper(
65             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockDomains));
66     mockServiceHelper.start();
67   }
68 
69   @AfterClass
stopServer()70   public static void stopServer() {
71     mockServiceHelper.stop();
72   }
73 
74   @Before
setUp()75   public void setUp() throws IOException {
76     mockServiceHelper.reset();
77     channelProvider = mockServiceHelper.createChannelProvider();
78     DomainsSettings settings =
79         DomainsSettings.newBuilder()
80             .setTransportChannelProvider(channelProvider)
81             .setCredentialsProvider(NoCredentialsProvider.create())
82             .build();
83     client = DomainsClient.create(settings);
84   }
85 
86   @After
tearDown()87   public void tearDown() throws Exception {
88     client.close();
89   }
90 
91   @Test
searchDomainsTest()92   public void searchDomainsTest() throws Exception {
93     SearchDomainsResponse expectedResponse =
94         SearchDomainsResponse.newBuilder()
95             .addAllRegisterParameters(new ArrayList<RegisterParameters>())
96             .build();
97     mockDomains.addResponse(expectedResponse);
98 
99     LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
100     String query = "query107944136";
101 
102     SearchDomainsResponse actualResponse = client.searchDomains(location, query);
103     Assert.assertEquals(expectedResponse, actualResponse);
104 
105     List<AbstractMessage> actualRequests = mockDomains.getRequests();
106     Assert.assertEquals(1, actualRequests.size());
107     SearchDomainsRequest actualRequest = ((SearchDomainsRequest) actualRequests.get(0));
108 
109     Assert.assertEquals(location.toString(), actualRequest.getLocation());
110     Assert.assertEquals(query, actualRequest.getQuery());
111     Assert.assertTrue(
112         channelProvider.isHeaderSent(
113             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
114             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
115   }
116 
117   @Test
searchDomainsExceptionTest()118   public void searchDomainsExceptionTest() throws Exception {
119     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
120     mockDomains.addException(exception);
121 
122     try {
123       LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
124       String query = "query107944136";
125       client.searchDomains(location, query);
126       Assert.fail("No exception raised");
127     } catch (InvalidArgumentException e) {
128       // Expected exception.
129     }
130   }
131 
132   @Test
searchDomainsTest2()133   public void searchDomainsTest2() throws Exception {
134     SearchDomainsResponse expectedResponse =
135         SearchDomainsResponse.newBuilder()
136             .addAllRegisterParameters(new ArrayList<RegisterParameters>())
137             .build();
138     mockDomains.addResponse(expectedResponse);
139 
140     String location = "location1901043637";
141     String query = "query107944136";
142 
143     SearchDomainsResponse actualResponse = client.searchDomains(location, query);
144     Assert.assertEquals(expectedResponse, actualResponse);
145 
146     List<AbstractMessage> actualRequests = mockDomains.getRequests();
147     Assert.assertEquals(1, actualRequests.size());
148     SearchDomainsRequest actualRequest = ((SearchDomainsRequest) actualRequests.get(0));
149 
150     Assert.assertEquals(location, actualRequest.getLocation());
151     Assert.assertEquals(query, actualRequest.getQuery());
152     Assert.assertTrue(
153         channelProvider.isHeaderSent(
154             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
155             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
156   }
157 
158   @Test
searchDomainsExceptionTest2()159   public void searchDomainsExceptionTest2() throws Exception {
160     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
161     mockDomains.addException(exception);
162 
163     try {
164       String location = "location1901043637";
165       String query = "query107944136";
166       client.searchDomains(location, query);
167       Assert.fail("No exception raised");
168     } catch (InvalidArgumentException e) {
169       // Expected exception.
170     }
171   }
172 
173   @Test
retrieveRegisterParametersTest()174   public void retrieveRegisterParametersTest() throws Exception {
175     RetrieveRegisterParametersResponse expectedResponse =
176         RetrieveRegisterParametersResponse.newBuilder()
177             .setRegisterParameters(RegisterParameters.newBuilder().build())
178             .build();
179     mockDomains.addResponse(expectedResponse);
180 
181     LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
182     String domainName = "domainName-1244085905";
183 
184     RetrieveRegisterParametersResponse actualResponse =
185         client.retrieveRegisterParameters(location, domainName);
186     Assert.assertEquals(expectedResponse, actualResponse);
187 
188     List<AbstractMessage> actualRequests = mockDomains.getRequests();
189     Assert.assertEquals(1, actualRequests.size());
190     RetrieveRegisterParametersRequest actualRequest =
191         ((RetrieveRegisterParametersRequest) actualRequests.get(0));
192 
193     Assert.assertEquals(location.toString(), actualRequest.getLocation());
194     Assert.assertEquals(domainName, actualRequest.getDomainName());
195     Assert.assertTrue(
196         channelProvider.isHeaderSent(
197             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
198             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
199   }
200 
201   @Test
retrieveRegisterParametersExceptionTest()202   public void retrieveRegisterParametersExceptionTest() throws Exception {
203     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
204     mockDomains.addException(exception);
205 
206     try {
207       LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
208       String domainName = "domainName-1244085905";
209       client.retrieveRegisterParameters(location, domainName);
210       Assert.fail("No exception raised");
211     } catch (InvalidArgumentException e) {
212       // Expected exception.
213     }
214   }
215 
216   @Test
retrieveRegisterParametersTest2()217   public void retrieveRegisterParametersTest2() throws Exception {
218     RetrieveRegisterParametersResponse expectedResponse =
219         RetrieveRegisterParametersResponse.newBuilder()
220             .setRegisterParameters(RegisterParameters.newBuilder().build())
221             .build();
222     mockDomains.addResponse(expectedResponse);
223 
224     String location = "location1901043637";
225     String domainName = "domainName-1244085905";
226 
227     RetrieveRegisterParametersResponse actualResponse =
228         client.retrieveRegisterParameters(location, domainName);
229     Assert.assertEquals(expectedResponse, actualResponse);
230 
231     List<AbstractMessage> actualRequests = mockDomains.getRequests();
232     Assert.assertEquals(1, actualRequests.size());
233     RetrieveRegisterParametersRequest actualRequest =
234         ((RetrieveRegisterParametersRequest) actualRequests.get(0));
235 
236     Assert.assertEquals(location, actualRequest.getLocation());
237     Assert.assertEquals(domainName, actualRequest.getDomainName());
238     Assert.assertTrue(
239         channelProvider.isHeaderSent(
240             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
241             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
242   }
243 
244   @Test
retrieveRegisterParametersExceptionTest2()245   public void retrieveRegisterParametersExceptionTest2() throws Exception {
246     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
247     mockDomains.addException(exception);
248 
249     try {
250       String location = "location1901043637";
251       String domainName = "domainName-1244085905";
252       client.retrieveRegisterParameters(location, domainName);
253       Assert.fail("No exception raised");
254     } catch (InvalidArgumentException e) {
255       // Expected exception.
256     }
257   }
258 
259   @Test
registerDomainTest()260   public void registerDomainTest() throws Exception {
261     Registration expectedResponse =
262         Registration.newBuilder()
263             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
264             .setDomainName("domainName-1244085905")
265             .setCreateTime(Timestamp.newBuilder().build())
266             .setExpireTime(Timestamp.newBuilder().build())
267             .addAllIssues(new ArrayList<Registration.Issue>())
268             .putAllLabels(new HashMap<String, String>())
269             .setManagementSettings(ManagementSettings.newBuilder().build())
270             .setDnsSettings(DnsSettings.newBuilder().build())
271             .setContactSettings(ContactSettings.newBuilder().build())
272             .setPendingContactSettings(ContactSettings.newBuilder().build())
273             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
274             .build();
275     Operation resultOperation =
276         Operation.newBuilder()
277             .setName("registerDomainTest")
278             .setDone(true)
279             .setResponse(Any.pack(expectedResponse))
280             .build();
281     mockDomains.addResponse(resultOperation);
282 
283     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
284     Registration registration = Registration.newBuilder().build();
285     Money yearlyPrice = Money.newBuilder().build();
286 
287     Registration actualResponse =
288         client.registerDomainAsync(parent, registration, yearlyPrice).get();
289     Assert.assertEquals(expectedResponse, actualResponse);
290 
291     List<AbstractMessage> actualRequests = mockDomains.getRequests();
292     Assert.assertEquals(1, actualRequests.size());
293     RegisterDomainRequest actualRequest = ((RegisterDomainRequest) actualRequests.get(0));
294 
295     Assert.assertEquals(parent.toString(), actualRequest.getParent());
296     Assert.assertEquals(registration, actualRequest.getRegistration());
297     Assert.assertEquals(yearlyPrice, actualRequest.getYearlyPrice());
298     Assert.assertTrue(
299         channelProvider.isHeaderSent(
300             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
301             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
302   }
303 
304   @Test
registerDomainExceptionTest()305   public void registerDomainExceptionTest() throws Exception {
306     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
307     mockDomains.addException(exception);
308 
309     try {
310       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
311       Registration registration = Registration.newBuilder().build();
312       Money yearlyPrice = Money.newBuilder().build();
313       client.registerDomainAsync(parent, registration, yearlyPrice).get();
314       Assert.fail("No exception raised");
315     } catch (ExecutionException e) {
316       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
317       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
318       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
319     }
320   }
321 
322   @Test
registerDomainTest2()323   public void registerDomainTest2() throws Exception {
324     Registration expectedResponse =
325         Registration.newBuilder()
326             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
327             .setDomainName("domainName-1244085905")
328             .setCreateTime(Timestamp.newBuilder().build())
329             .setExpireTime(Timestamp.newBuilder().build())
330             .addAllIssues(new ArrayList<Registration.Issue>())
331             .putAllLabels(new HashMap<String, String>())
332             .setManagementSettings(ManagementSettings.newBuilder().build())
333             .setDnsSettings(DnsSettings.newBuilder().build())
334             .setContactSettings(ContactSettings.newBuilder().build())
335             .setPendingContactSettings(ContactSettings.newBuilder().build())
336             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
337             .build();
338     Operation resultOperation =
339         Operation.newBuilder()
340             .setName("registerDomainTest")
341             .setDone(true)
342             .setResponse(Any.pack(expectedResponse))
343             .build();
344     mockDomains.addResponse(resultOperation);
345 
346     String parent = "parent-995424086";
347     Registration registration = Registration.newBuilder().build();
348     Money yearlyPrice = Money.newBuilder().build();
349 
350     Registration actualResponse =
351         client.registerDomainAsync(parent, registration, yearlyPrice).get();
352     Assert.assertEquals(expectedResponse, actualResponse);
353 
354     List<AbstractMessage> actualRequests = mockDomains.getRequests();
355     Assert.assertEquals(1, actualRequests.size());
356     RegisterDomainRequest actualRequest = ((RegisterDomainRequest) actualRequests.get(0));
357 
358     Assert.assertEquals(parent, actualRequest.getParent());
359     Assert.assertEquals(registration, actualRequest.getRegistration());
360     Assert.assertEquals(yearlyPrice, actualRequest.getYearlyPrice());
361     Assert.assertTrue(
362         channelProvider.isHeaderSent(
363             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
364             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
365   }
366 
367   @Test
registerDomainExceptionTest2()368   public void registerDomainExceptionTest2() throws Exception {
369     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
370     mockDomains.addException(exception);
371 
372     try {
373       String parent = "parent-995424086";
374       Registration registration = Registration.newBuilder().build();
375       Money yearlyPrice = Money.newBuilder().build();
376       client.registerDomainAsync(parent, registration, yearlyPrice).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
retrieveTransferParametersTest()386   public void retrieveTransferParametersTest() throws Exception {
387     RetrieveTransferParametersResponse expectedResponse =
388         RetrieveTransferParametersResponse.newBuilder()
389             .setTransferParameters(TransferParameters.newBuilder().build())
390             .build();
391     mockDomains.addResponse(expectedResponse);
392 
393     LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
394     String domainName = "domainName-1244085905";
395 
396     RetrieveTransferParametersResponse actualResponse =
397         client.retrieveTransferParameters(location, domainName);
398     Assert.assertEquals(expectedResponse, actualResponse);
399 
400     List<AbstractMessage> actualRequests = mockDomains.getRequests();
401     Assert.assertEquals(1, actualRequests.size());
402     RetrieveTransferParametersRequest actualRequest =
403         ((RetrieveTransferParametersRequest) actualRequests.get(0));
404 
405     Assert.assertEquals(location.toString(), actualRequest.getLocation());
406     Assert.assertEquals(domainName, actualRequest.getDomainName());
407     Assert.assertTrue(
408         channelProvider.isHeaderSent(
409             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
410             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
411   }
412 
413   @Test
retrieveTransferParametersExceptionTest()414   public void retrieveTransferParametersExceptionTest() throws Exception {
415     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
416     mockDomains.addException(exception);
417 
418     try {
419       LocationName location = LocationName.of("[PROJECT]", "[LOCATION]");
420       String domainName = "domainName-1244085905";
421       client.retrieveTransferParameters(location, domainName);
422       Assert.fail("No exception raised");
423     } catch (InvalidArgumentException e) {
424       // Expected exception.
425     }
426   }
427 
428   @Test
retrieveTransferParametersTest2()429   public void retrieveTransferParametersTest2() throws Exception {
430     RetrieveTransferParametersResponse expectedResponse =
431         RetrieveTransferParametersResponse.newBuilder()
432             .setTransferParameters(TransferParameters.newBuilder().build())
433             .build();
434     mockDomains.addResponse(expectedResponse);
435 
436     String location = "location1901043637";
437     String domainName = "domainName-1244085905";
438 
439     RetrieveTransferParametersResponse actualResponse =
440         client.retrieveTransferParameters(location, domainName);
441     Assert.assertEquals(expectedResponse, actualResponse);
442 
443     List<AbstractMessage> actualRequests = mockDomains.getRequests();
444     Assert.assertEquals(1, actualRequests.size());
445     RetrieveTransferParametersRequest actualRequest =
446         ((RetrieveTransferParametersRequest) actualRequests.get(0));
447 
448     Assert.assertEquals(location, actualRequest.getLocation());
449     Assert.assertEquals(domainName, actualRequest.getDomainName());
450     Assert.assertTrue(
451         channelProvider.isHeaderSent(
452             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
453             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
454   }
455 
456   @Test
retrieveTransferParametersExceptionTest2()457   public void retrieveTransferParametersExceptionTest2() throws Exception {
458     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
459     mockDomains.addException(exception);
460 
461     try {
462       String location = "location1901043637";
463       String domainName = "domainName-1244085905";
464       client.retrieveTransferParameters(location, domainName);
465       Assert.fail("No exception raised");
466     } catch (InvalidArgumentException e) {
467       // Expected exception.
468     }
469   }
470 
471   @Test
transferDomainTest()472   public void transferDomainTest() throws Exception {
473     Registration expectedResponse =
474         Registration.newBuilder()
475             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
476             .setDomainName("domainName-1244085905")
477             .setCreateTime(Timestamp.newBuilder().build())
478             .setExpireTime(Timestamp.newBuilder().build())
479             .addAllIssues(new ArrayList<Registration.Issue>())
480             .putAllLabels(new HashMap<String, String>())
481             .setManagementSettings(ManagementSettings.newBuilder().build())
482             .setDnsSettings(DnsSettings.newBuilder().build())
483             .setContactSettings(ContactSettings.newBuilder().build())
484             .setPendingContactSettings(ContactSettings.newBuilder().build())
485             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
486             .build();
487     Operation resultOperation =
488         Operation.newBuilder()
489             .setName("transferDomainTest")
490             .setDone(true)
491             .setResponse(Any.pack(expectedResponse))
492             .build();
493     mockDomains.addResponse(resultOperation);
494 
495     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
496     Registration registration = Registration.newBuilder().build();
497     Money yearlyPrice = Money.newBuilder().build();
498     AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
499 
500     Registration actualResponse =
501         client.transferDomainAsync(parent, registration, yearlyPrice, authorizationCode).get();
502     Assert.assertEquals(expectedResponse, actualResponse);
503 
504     List<AbstractMessage> actualRequests = mockDomains.getRequests();
505     Assert.assertEquals(1, actualRequests.size());
506     TransferDomainRequest actualRequest = ((TransferDomainRequest) actualRequests.get(0));
507 
508     Assert.assertEquals(parent.toString(), actualRequest.getParent());
509     Assert.assertEquals(registration, actualRequest.getRegistration());
510     Assert.assertEquals(yearlyPrice, actualRequest.getYearlyPrice());
511     Assert.assertEquals(authorizationCode, actualRequest.getAuthorizationCode());
512     Assert.assertTrue(
513         channelProvider.isHeaderSent(
514             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
515             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
516   }
517 
518   @Test
transferDomainExceptionTest()519   public void transferDomainExceptionTest() throws Exception {
520     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
521     mockDomains.addException(exception);
522 
523     try {
524       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
525       Registration registration = Registration.newBuilder().build();
526       Money yearlyPrice = Money.newBuilder().build();
527       AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
528       client.transferDomainAsync(parent, registration, yearlyPrice, authorizationCode).get();
529       Assert.fail("No exception raised");
530     } catch (ExecutionException e) {
531       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
532       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
533       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
534     }
535   }
536 
537   @Test
transferDomainTest2()538   public void transferDomainTest2() throws Exception {
539     Registration expectedResponse =
540         Registration.newBuilder()
541             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
542             .setDomainName("domainName-1244085905")
543             .setCreateTime(Timestamp.newBuilder().build())
544             .setExpireTime(Timestamp.newBuilder().build())
545             .addAllIssues(new ArrayList<Registration.Issue>())
546             .putAllLabels(new HashMap<String, String>())
547             .setManagementSettings(ManagementSettings.newBuilder().build())
548             .setDnsSettings(DnsSettings.newBuilder().build())
549             .setContactSettings(ContactSettings.newBuilder().build())
550             .setPendingContactSettings(ContactSettings.newBuilder().build())
551             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
552             .build();
553     Operation resultOperation =
554         Operation.newBuilder()
555             .setName("transferDomainTest")
556             .setDone(true)
557             .setResponse(Any.pack(expectedResponse))
558             .build();
559     mockDomains.addResponse(resultOperation);
560 
561     String parent = "parent-995424086";
562     Registration registration = Registration.newBuilder().build();
563     Money yearlyPrice = Money.newBuilder().build();
564     AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
565 
566     Registration actualResponse =
567         client.transferDomainAsync(parent, registration, yearlyPrice, authorizationCode).get();
568     Assert.assertEquals(expectedResponse, actualResponse);
569 
570     List<AbstractMessage> actualRequests = mockDomains.getRequests();
571     Assert.assertEquals(1, actualRequests.size());
572     TransferDomainRequest actualRequest = ((TransferDomainRequest) actualRequests.get(0));
573 
574     Assert.assertEquals(parent, actualRequest.getParent());
575     Assert.assertEquals(registration, actualRequest.getRegistration());
576     Assert.assertEquals(yearlyPrice, actualRequest.getYearlyPrice());
577     Assert.assertEquals(authorizationCode, actualRequest.getAuthorizationCode());
578     Assert.assertTrue(
579         channelProvider.isHeaderSent(
580             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
581             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
582   }
583 
584   @Test
transferDomainExceptionTest2()585   public void transferDomainExceptionTest2() throws Exception {
586     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
587     mockDomains.addException(exception);
588 
589     try {
590       String parent = "parent-995424086";
591       Registration registration = Registration.newBuilder().build();
592       Money yearlyPrice = Money.newBuilder().build();
593       AuthorizationCode authorizationCode = AuthorizationCode.newBuilder().build();
594       client.transferDomainAsync(parent, registration, yearlyPrice, authorizationCode).get();
595       Assert.fail("No exception raised");
596     } catch (ExecutionException e) {
597       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
598       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
599       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
600     }
601   }
602 
603   @Test
listRegistrationsTest()604   public void listRegistrationsTest() throws Exception {
605     Registration responsesElement = Registration.newBuilder().build();
606     ListRegistrationsResponse expectedResponse =
607         ListRegistrationsResponse.newBuilder()
608             .setNextPageToken("")
609             .addAllRegistrations(Arrays.asList(responsesElement))
610             .build();
611     mockDomains.addResponse(expectedResponse);
612 
613     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
614 
615     ListRegistrationsPagedResponse pagedListResponse = client.listRegistrations(parent);
616 
617     List<Registration> resources = Lists.newArrayList(pagedListResponse.iterateAll());
618 
619     Assert.assertEquals(1, resources.size());
620     Assert.assertEquals(expectedResponse.getRegistrationsList().get(0), resources.get(0));
621 
622     List<AbstractMessage> actualRequests = mockDomains.getRequests();
623     Assert.assertEquals(1, actualRequests.size());
624     ListRegistrationsRequest actualRequest = ((ListRegistrationsRequest) actualRequests.get(0));
625 
626     Assert.assertEquals(parent.toString(), actualRequest.getParent());
627     Assert.assertTrue(
628         channelProvider.isHeaderSent(
629             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
630             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
631   }
632 
633   @Test
listRegistrationsExceptionTest()634   public void listRegistrationsExceptionTest() throws Exception {
635     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
636     mockDomains.addException(exception);
637 
638     try {
639       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
640       client.listRegistrations(parent);
641       Assert.fail("No exception raised");
642     } catch (InvalidArgumentException e) {
643       // Expected exception.
644     }
645   }
646 
647   @Test
listRegistrationsTest2()648   public void listRegistrationsTest2() throws Exception {
649     Registration responsesElement = Registration.newBuilder().build();
650     ListRegistrationsResponse expectedResponse =
651         ListRegistrationsResponse.newBuilder()
652             .setNextPageToken("")
653             .addAllRegistrations(Arrays.asList(responsesElement))
654             .build();
655     mockDomains.addResponse(expectedResponse);
656 
657     String parent = "parent-995424086";
658 
659     ListRegistrationsPagedResponse pagedListResponse = client.listRegistrations(parent);
660 
661     List<Registration> resources = Lists.newArrayList(pagedListResponse.iterateAll());
662 
663     Assert.assertEquals(1, resources.size());
664     Assert.assertEquals(expectedResponse.getRegistrationsList().get(0), resources.get(0));
665 
666     List<AbstractMessage> actualRequests = mockDomains.getRequests();
667     Assert.assertEquals(1, actualRequests.size());
668     ListRegistrationsRequest actualRequest = ((ListRegistrationsRequest) actualRequests.get(0));
669 
670     Assert.assertEquals(parent, actualRequest.getParent());
671     Assert.assertTrue(
672         channelProvider.isHeaderSent(
673             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
674             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
675   }
676 
677   @Test
listRegistrationsExceptionTest2()678   public void listRegistrationsExceptionTest2() throws Exception {
679     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
680     mockDomains.addException(exception);
681 
682     try {
683       String parent = "parent-995424086";
684       client.listRegistrations(parent);
685       Assert.fail("No exception raised");
686     } catch (InvalidArgumentException e) {
687       // Expected exception.
688     }
689   }
690 
691   @Test
getRegistrationTest()692   public void getRegistrationTest() throws Exception {
693     Registration expectedResponse =
694         Registration.newBuilder()
695             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
696             .setDomainName("domainName-1244085905")
697             .setCreateTime(Timestamp.newBuilder().build())
698             .setExpireTime(Timestamp.newBuilder().build())
699             .addAllIssues(new ArrayList<Registration.Issue>())
700             .putAllLabels(new HashMap<String, String>())
701             .setManagementSettings(ManagementSettings.newBuilder().build())
702             .setDnsSettings(DnsSettings.newBuilder().build())
703             .setContactSettings(ContactSettings.newBuilder().build())
704             .setPendingContactSettings(ContactSettings.newBuilder().build())
705             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
706             .build();
707     mockDomains.addResponse(expectedResponse);
708 
709     RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
710 
711     Registration actualResponse = client.getRegistration(name);
712     Assert.assertEquals(expectedResponse, actualResponse);
713 
714     List<AbstractMessage> actualRequests = mockDomains.getRequests();
715     Assert.assertEquals(1, actualRequests.size());
716     GetRegistrationRequest actualRequest = ((GetRegistrationRequest) actualRequests.get(0));
717 
718     Assert.assertEquals(name.toString(), actualRequest.getName());
719     Assert.assertTrue(
720         channelProvider.isHeaderSent(
721             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
722             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
723   }
724 
725   @Test
getRegistrationExceptionTest()726   public void getRegistrationExceptionTest() throws Exception {
727     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
728     mockDomains.addException(exception);
729 
730     try {
731       RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
732       client.getRegistration(name);
733       Assert.fail("No exception raised");
734     } catch (InvalidArgumentException e) {
735       // Expected exception.
736     }
737   }
738 
739   @Test
getRegistrationTest2()740   public void getRegistrationTest2() throws Exception {
741     Registration expectedResponse =
742         Registration.newBuilder()
743             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
744             .setDomainName("domainName-1244085905")
745             .setCreateTime(Timestamp.newBuilder().build())
746             .setExpireTime(Timestamp.newBuilder().build())
747             .addAllIssues(new ArrayList<Registration.Issue>())
748             .putAllLabels(new HashMap<String, String>())
749             .setManagementSettings(ManagementSettings.newBuilder().build())
750             .setDnsSettings(DnsSettings.newBuilder().build())
751             .setContactSettings(ContactSettings.newBuilder().build())
752             .setPendingContactSettings(ContactSettings.newBuilder().build())
753             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
754             .build();
755     mockDomains.addResponse(expectedResponse);
756 
757     String name = "name3373707";
758 
759     Registration actualResponse = client.getRegistration(name);
760     Assert.assertEquals(expectedResponse, actualResponse);
761 
762     List<AbstractMessage> actualRequests = mockDomains.getRequests();
763     Assert.assertEquals(1, actualRequests.size());
764     GetRegistrationRequest actualRequest = ((GetRegistrationRequest) actualRequests.get(0));
765 
766     Assert.assertEquals(name, actualRequest.getName());
767     Assert.assertTrue(
768         channelProvider.isHeaderSent(
769             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
770             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
771   }
772 
773   @Test
getRegistrationExceptionTest2()774   public void getRegistrationExceptionTest2() throws Exception {
775     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
776     mockDomains.addException(exception);
777 
778     try {
779       String name = "name3373707";
780       client.getRegistration(name);
781       Assert.fail("No exception raised");
782     } catch (InvalidArgumentException e) {
783       // Expected exception.
784     }
785   }
786 
787   @Test
updateRegistrationTest()788   public void updateRegistrationTest() throws Exception {
789     Registration expectedResponse =
790         Registration.newBuilder()
791             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
792             .setDomainName("domainName-1244085905")
793             .setCreateTime(Timestamp.newBuilder().build())
794             .setExpireTime(Timestamp.newBuilder().build())
795             .addAllIssues(new ArrayList<Registration.Issue>())
796             .putAllLabels(new HashMap<String, String>())
797             .setManagementSettings(ManagementSettings.newBuilder().build())
798             .setDnsSettings(DnsSettings.newBuilder().build())
799             .setContactSettings(ContactSettings.newBuilder().build())
800             .setPendingContactSettings(ContactSettings.newBuilder().build())
801             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
802             .build();
803     Operation resultOperation =
804         Operation.newBuilder()
805             .setName("updateRegistrationTest")
806             .setDone(true)
807             .setResponse(Any.pack(expectedResponse))
808             .build();
809     mockDomains.addResponse(resultOperation);
810 
811     Registration registration = Registration.newBuilder().build();
812     FieldMask updateMask = FieldMask.newBuilder().build();
813 
814     Registration actualResponse = client.updateRegistrationAsync(registration, updateMask).get();
815     Assert.assertEquals(expectedResponse, actualResponse);
816 
817     List<AbstractMessage> actualRequests = mockDomains.getRequests();
818     Assert.assertEquals(1, actualRequests.size());
819     UpdateRegistrationRequest actualRequest = ((UpdateRegistrationRequest) actualRequests.get(0));
820 
821     Assert.assertEquals(registration, actualRequest.getRegistration());
822     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
823     Assert.assertTrue(
824         channelProvider.isHeaderSent(
825             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
826             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
827   }
828 
829   @Test
updateRegistrationExceptionTest()830   public void updateRegistrationExceptionTest() throws Exception {
831     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
832     mockDomains.addException(exception);
833 
834     try {
835       Registration registration = Registration.newBuilder().build();
836       FieldMask updateMask = FieldMask.newBuilder().build();
837       client.updateRegistrationAsync(registration, updateMask).get();
838       Assert.fail("No exception raised");
839     } catch (ExecutionException e) {
840       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
841       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
842       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
843     }
844   }
845 
846   @Test
configureManagementSettingsTest()847   public void configureManagementSettingsTest() throws Exception {
848     Registration expectedResponse =
849         Registration.newBuilder()
850             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
851             .setDomainName("domainName-1244085905")
852             .setCreateTime(Timestamp.newBuilder().build())
853             .setExpireTime(Timestamp.newBuilder().build())
854             .addAllIssues(new ArrayList<Registration.Issue>())
855             .putAllLabels(new HashMap<String, String>())
856             .setManagementSettings(ManagementSettings.newBuilder().build())
857             .setDnsSettings(DnsSettings.newBuilder().build())
858             .setContactSettings(ContactSettings.newBuilder().build())
859             .setPendingContactSettings(ContactSettings.newBuilder().build())
860             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
861             .build();
862     Operation resultOperation =
863         Operation.newBuilder()
864             .setName("configureManagementSettingsTest")
865             .setDone(true)
866             .setResponse(Any.pack(expectedResponse))
867             .build();
868     mockDomains.addResponse(resultOperation);
869 
870     RegistrationName registration =
871         RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
872     ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
873     FieldMask updateMask = FieldMask.newBuilder().build();
874 
875     Registration actualResponse =
876         client.configureManagementSettingsAsync(registration, managementSettings, updateMask).get();
877     Assert.assertEquals(expectedResponse, actualResponse);
878 
879     List<AbstractMessage> actualRequests = mockDomains.getRequests();
880     Assert.assertEquals(1, actualRequests.size());
881     ConfigureManagementSettingsRequest actualRequest =
882         ((ConfigureManagementSettingsRequest) actualRequests.get(0));
883 
884     Assert.assertEquals(registration.toString(), actualRequest.getRegistration());
885     Assert.assertEquals(managementSettings, actualRequest.getManagementSettings());
886     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
887     Assert.assertTrue(
888         channelProvider.isHeaderSent(
889             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
890             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
891   }
892 
893   @Test
configureManagementSettingsExceptionTest()894   public void configureManagementSettingsExceptionTest() throws Exception {
895     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
896     mockDomains.addException(exception);
897 
898     try {
899       RegistrationName registration =
900           RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
901       ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
902       FieldMask updateMask = FieldMask.newBuilder().build();
903       client.configureManagementSettingsAsync(registration, managementSettings, updateMask).get();
904       Assert.fail("No exception raised");
905     } catch (ExecutionException e) {
906       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
907       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
908       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
909     }
910   }
911 
912   @Test
configureManagementSettingsTest2()913   public void configureManagementSettingsTest2() throws Exception {
914     Registration expectedResponse =
915         Registration.newBuilder()
916             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
917             .setDomainName("domainName-1244085905")
918             .setCreateTime(Timestamp.newBuilder().build())
919             .setExpireTime(Timestamp.newBuilder().build())
920             .addAllIssues(new ArrayList<Registration.Issue>())
921             .putAllLabels(new HashMap<String, String>())
922             .setManagementSettings(ManagementSettings.newBuilder().build())
923             .setDnsSettings(DnsSettings.newBuilder().build())
924             .setContactSettings(ContactSettings.newBuilder().build())
925             .setPendingContactSettings(ContactSettings.newBuilder().build())
926             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
927             .build();
928     Operation resultOperation =
929         Operation.newBuilder()
930             .setName("configureManagementSettingsTest")
931             .setDone(true)
932             .setResponse(Any.pack(expectedResponse))
933             .build();
934     mockDomains.addResponse(resultOperation);
935 
936     String registration = "registration-1350309703";
937     ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
938     FieldMask updateMask = FieldMask.newBuilder().build();
939 
940     Registration actualResponse =
941         client.configureManagementSettingsAsync(registration, managementSettings, updateMask).get();
942     Assert.assertEquals(expectedResponse, actualResponse);
943 
944     List<AbstractMessage> actualRequests = mockDomains.getRequests();
945     Assert.assertEquals(1, actualRequests.size());
946     ConfigureManagementSettingsRequest actualRequest =
947         ((ConfigureManagementSettingsRequest) actualRequests.get(0));
948 
949     Assert.assertEquals(registration, actualRequest.getRegistration());
950     Assert.assertEquals(managementSettings, actualRequest.getManagementSettings());
951     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
952     Assert.assertTrue(
953         channelProvider.isHeaderSent(
954             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
955             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
956   }
957 
958   @Test
configureManagementSettingsExceptionTest2()959   public void configureManagementSettingsExceptionTest2() throws Exception {
960     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
961     mockDomains.addException(exception);
962 
963     try {
964       String registration = "registration-1350309703";
965       ManagementSettings managementSettings = ManagementSettings.newBuilder().build();
966       FieldMask updateMask = FieldMask.newBuilder().build();
967       client.configureManagementSettingsAsync(registration, managementSettings, updateMask).get();
968       Assert.fail("No exception raised");
969     } catch (ExecutionException e) {
970       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
971       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
972       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
973     }
974   }
975 
976   @Test
configureDnsSettingsTest()977   public void configureDnsSettingsTest() throws Exception {
978     Registration expectedResponse =
979         Registration.newBuilder()
980             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
981             .setDomainName("domainName-1244085905")
982             .setCreateTime(Timestamp.newBuilder().build())
983             .setExpireTime(Timestamp.newBuilder().build())
984             .addAllIssues(new ArrayList<Registration.Issue>())
985             .putAllLabels(new HashMap<String, String>())
986             .setManagementSettings(ManagementSettings.newBuilder().build())
987             .setDnsSettings(DnsSettings.newBuilder().build())
988             .setContactSettings(ContactSettings.newBuilder().build())
989             .setPendingContactSettings(ContactSettings.newBuilder().build())
990             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
991             .build();
992     Operation resultOperation =
993         Operation.newBuilder()
994             .setName("configureDnsSettingsTest")
995             .setDone(true)
996             .setResponse(Any.pack(expectedResponse))
997             .build();
998     mockDomains.addResponse(resultOperation);
999 
1000     RegistrationName registration =
1001         RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1002     DnsSettings dnsSettings = DnsSettings.newBuilder().build();
1003     FieldMask updateMask = FieldMask.newBuilder().build();
1004 
1005     Registration actualResponse =
1006         client.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
1007     Assert.assertEquals(expectedResponse, actualResponse);
1008 
1009     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1010     Assert.assertEquals(1, actualRequests.size());
1011     ConfigureDnsSettingsRequest actualRequest =
1012         ((ConfigureDnsSettingsRequest) actualRequests.get(0));
1013 
1014     Assert.assertEquals(registration.toString(), actualRequest.getRegistration());
1015     Assert.assertEquals(dnsSettings, actualRequest.getDnsSettings());
1016     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1017     Assert.assertTrue(
1018         channelProvider.isHeaderSent(
1019             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1020             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1021   }
1022 
1023   @Test
configureDnsSettingsExceptionTest()1024   public void configureDnsSettingsExceptionTest() throws Exception {
1025     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1026     mockDomains.addException(exception);
1027 
1028     try {
1029       RegistrationName registration =
1030           RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1031       DnsSettings dnsSettings = DnsSettings.newBuilder().build();
1032       FieldMask updateMask = FieldMask.newBuilder().build();
1033       client.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
1034       Assert.fail("No exception raised");
1035     } catch (ExecutionException e) {
1036       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1037       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1038       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1039     }
1040   }
1041 
1042   @Test
configureDnsSettingsTest2()1043   public void configureDnsSettingsTest2() throws Exception {
1044     Registration expectedResponse =
1045         Registration.newBuilder()
1046             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
1047             .setDomainName("domainName-1244085905")
1048             .setCreateTime(Timestamp.newBuilder().build())
1049             .setExpireTime(Timestamp.newBuilder().build())
1050             .addAllIssues(new ArrayList<Registration.Issue>())
1051             .putAllLabels(new HashMap<String, String>())
1052             .setManagementSettings(ManagementSettings.newBuilder().build())
1053             .setDnsSettings(DnsSettings.newBuilder().build())
1054             .setContactSettings(ContactSettings.newBuilder().build())
1055             .setPendingContactSettings(ContactSettings.newBuilder().build())
1056             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
1057             .build();
1058     Operation resultOperation =
1059         Operation.newBuilder()
1060             .setName("configureDnsSettingsTest")
1061             .setDone(true)
1062             .setResponse(Any.pack(expectedResponse))
1063             .build();
1064     mockDomains.addResponse(resultOperation);
1065 
1066     String registration = "registration-1350309703";
1067     DnsSettings dnsSettings = DnsSettings.newBuilder().build();
1068     FieldMask updateMask = FieldMask.newBuilder().build();
1069 
1070     Registration actualResponse =
1071         client.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
1072     Assert.assertEquals(expectedResponse, actualResponse);
1073 
1074     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1075     Assert.assertEquals(1, actualRequests.size());
1076     ConfigureDnsSettingsRequest actualRequest =
1077         ((ConfigureDnsSettingsRequest) actualRequests.get(0));
1078 
1079     Assert.assertEquals(registration, actualRequest.getRegistration());
1080     Assert.assertEquals(dnsSettings, actualRequest.getDnsSettings());
1081     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1082     Assert.assertTrue(
1083         channelProvider.isHeaderSent(
1084             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1085             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1086   }
1087 
1088   @Test
configureDnsSettingsExceptionTest2()1089   public void configureDnsSettingsExceptionTest2() throws Exception {
1090     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1091     mockDomains.addException(exception);
1092 
1093     try {
1094       String registration = "registration-1350309703";
1095       DnsSettings dnsSettings = DnsSettings.newBuilder().build();
1096       FieldMask updateMask = FieldMask.newBuilder().build();
1097       client.configureDnsSettingsAsync(registration, dnsSettings, updateMask).get();
1098       Assert.fail("No exception raised");
1099     } catch (ExecutionException e) {
1100       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1101       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1102       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1103     }
1104   }
1105 
1106   @Test
configureContactSettingsTest()1107   public void configureContactSettingsTest() throws Exception {
1108     Registration expectedResponse =
1109         Registration.newBuilder()
1110             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
1111             .setDomainName("domainName-1244085905")
1112             .setCreateTime(Timestamp.newBuilder().build())
1113             .setExpireTime(Timestamp.newBuilder().build())
1114             .addAllIssues(new ArrayList<Registration.Issue>())
1115             .putAllLabels(new HashMap<String, String>())
1116             .setManagementSettings(ManagementSettings.newBuilder().build())
1117             .setDnsSettings(DnsSettings.newBuilder().build())
1118             .setContactSettings(ContactSettings.newBuilder().build())
1119             .setPendingContactSettings(ContactSettings.newBuilder().build())
1120             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
1121             .build();
1122     Operation resultOperation =
1123         Operation.newBuilder()
1124             .setName("configureContactSettingsTest")
1125             .setDone(true)
1126             .setResponse(Any.pack(expectedResponse))
1127             .build();
1128     mockDomains.addResponse(resultOperation);
1129 
1130     RegistrationName registration =
1131         RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1132     ContactSettings contactSettings = ContactSettings.newBuilder().build();
1133     FieldMask updateMask = FieldMask.newBuilder().build();
1134 
1135     Registration actualResponse =
1136         client.configureContactSettingsAsync(registration, contactSettings, updateMask).get();
1137     Assert.assertEquals(expectedResponse, actualResponse);
1138 
1139     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1140     Assert.assertEquals(1, actualRequests.size());
1141     ConfigureContactSettingsRequest actualRequest =
1142         ((ConfigureContactSettingsRequest) actualRequests.get(0));
1143 
1144     Assert.assertEquals(registration.toString(), actualRequest.getRegistration());
1145     Assert.assertEquals(contactSettings, actualRequest.getContactSettings());
1146     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1147     Assert.assertTrue(
1148         channelProvider.isHeaderSent(
1149             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1150             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1151   }
1152 
1153   @Test
configureContactSettingsExceptionTest()1154   public void configureContactSettingsExceptionTest() throws Exception {
1155     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1156     mockDomains.addException(exception);
1157 
1158     try {
1159       RegistrationName registration =
1160           RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1161       ContactSettings contactSettings = ContactSettings.newBuilder().build();
1162       FieldMask updateMask = FieldMask.newBuilder().build();
1163       client.configureContactSettingsAsync(registration, contactSettings, updateMask).get();
1164       Assert.fail("No exception raised");
1165     } catch (ExecutionException e) {
1166       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1167       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1168       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1169     }
1170   }
1171 
1172   @Test
configureContactSettingsTest2()1173   public void configureContactSettingsTest2() throws Exception {
1174     Registration expectedResponse =
1175         Registration.newBuilder()
1176             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
1177             .setDomainName("domainName-1244085905")
1178             .setCreateTime(Timestamp.newBuilder().build())
1179             .setExpireTime(Timestamp.newBuilder().build())
1180             .addAllIssues(new ArrayList<Registration.Issue>())
1181             .putAllLabels(new HashMap<String, String>())
1182             .setManagementSettings(ManagementSettings.newBuilder().build())
1183             .setDnsSettings(DnsSettings.newBuilder().build())
1184             .setContactSettings(ContactSettings.newBuilder().build())
1185             .setPendingContactSettings(ContactSettings.newBuilder().build())
1186             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
1187             .build();
1188     Operation resultOperation =
1189         Operation.newBuilder()
1190             .setName("configureContactSettingsTest")
1191             .setDone(true)
1192             .setResponse(Any.pack(expectedResponse))
1193             .build();
1194     mockDomains.addResponse(resultOperation);
1195 
1196     String registration = "registration-1350309703";
1197     ContactSettings contactSettings = ContactSettings.newBuilder().build();
1198     FieldMask updateMask = FieldMask.newBuilder().build();
1199 
1200     Registration actualResponse =
1201         client.configureContactSettingsAsync(registration, contactSettings, updateMask).get();
1202     Assert.assertEquals(expectedResponse, actualResponse);
1203 
1204     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1205     Assert.assertEquals(1, actualRequests.size());
1206     ConfigureContactSettingsRequest actualRequest =
1207         ((ConfigureContactSettingsRequest) actualRequests.get(0));
1208 
1209     Assert.assertEquals(registration, actualRequest.getRegistration());
1210     Assert.assertEquals(contactSettings, actualRequest.getContactSettings());
1211     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
1212     Assert.assertTrue(
1213         channelProvider.isHeaderSent(
1214             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1215             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1216   }
1217 
1218   @Test
configureContactSettingsExceptionTest2()1219   public void configureContactSettingsExceptionTest2() throws Exception {
1220     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1221     mockDomains.addException(exception);
1222 
1223     try {
1224       String registration = "registration-1350309703";
1225       ContactSettings contactSettings = ContactSettings.newBuilder().build();
1226       FieldMask updateMask = FieldMask.newBuilder().build();
1227       client.configureContactSettingsAsync(registration, contactSettings, updateMask).get();
1228       Assert.fail("No exception raised");
1229     } catch (ExecutionException e) {
1230       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1231       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1232       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1233     }
1234   }
1235 
1236   @Test
exportRegistrationTest()1237   public void exportRegistrationTest() throws Exception {
1238     Registration expectedResponse =
1239         Registration.newBuilder()
1240             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
1241             .setDomainName("domainName-1244085905")
1242             .setCreateTime(Timestamp.newBuilder().build())
1243             .setExpireTime(Timestamp.newBuilder().build())
1244             .addAllIssues(new ArrayList<Registration.Issue>())
1245             .putAllLabels(new HashMap<String, String>())
1246             .setManagementSettings(ManagementSettings.newBuilder().build())
1247             .setDnsSettings(DnsSettings.newBuilder().build())
1248             .setContactSettings(ContactSettings.newBuilder().build())
1249             .setPendingContactSettings(ContactSettings.newBuilder().build())
1250             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
1251             .build();
1252     Operation resultOperation =
1253         Operation.newBuilder()
1254             .setName("exportRegistrationTest")
1255             .setDone(true)
1256             .setResponse(Any.pack(expectedResponse))
1257             .build();
1258     mockDomains.addResponse(resultOperation);
1259 
1260     RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1261 
1262     Registration actualResponse = client.exportRegistrationAsync(name).get();
1263     Assert.assertEquals(expectedResponse, actualResponse);
1264 
1265     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1266     Assert.assertEquals(1, actualRequests.size());
1267     ExportRegistrationRequest actualRequest = ((ExportRegistrationRequest) actualRequests.get(0));
1268 
1269     Assert.assertEquals(name.toString(), actualRequest.getName());
1270     Assert.assertTrue(
1271         channelProvider.isHeaderSent(
1272             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1273             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1274   }
1275 
1276   @Test
exportRegistrationExceptionTest()1277   public void exportRegistrationExceptionTest() throws Exception {
1278     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1279     mockDomains.addException(exception);
1280 
1281     try {
1282       RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1283       client.exportRegistrationAsync(name).get();
1284       Assert.fail("No exception raised");
1285     } catch (ExecutionException e) {
1286       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1287       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1288       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1289     }
1290   }
1291 
1292   @Test
exportRegistrationTest2()1293   public void exportRegistrationTest2() throws Exception {
1294     Registration expectedResponse =
1295         Registration.newBuilder()
1296             .setName(RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]").toString())
1297             .setDomainName("domainName-1244085905")
1298             .setCreateTime(Timestamp.newBuilder().build())
1299             .setExpireTime(Timestamp.newBuilder().build())
1300             .addAllIssues(new ArrayList<Registration.Issue>())
1301             .putAllLabels(new HashMap<String, String>())
1302             .setManagementSettings(ManagementSettings.newBuilder().build())
1303             .setDnsSettings(DnsSettings.newBuilder().build())
1304             .setContactSettings(ContactSettings.newBuilder().build())
1305             .setPendingContactSettings(ContactSettings.newBuilder().build())
1306             .addAllSupportedPrivacy(new ArrayList<ContactPrivacy>())
1307             .build();
1308     Operation resultOperation =
1309         Operation.newBuilder()
1310             .setName("exportRegistrationTest")
1311             .setDone(true)
1312             .setResponse(Any.pack(expectedResponse))
1313             .build();
1314     mockDomains.addResponse(resultOperation);
1315 
1316     String name = "name3373707";
1317 
1318     Registration actualResponse = client.exportRegistrationAsync(name).get();
1319     Assert.assertEquals(expectedResponse, actualResponse);
1320 
1321     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1322     Assert.assertEquals(1, actualRequests.size());
1323     ExportRegistrationRequest actualRequest = ((ExportRegistrationRequest) actualRequests.get(0));
1324 
1325     Assert.assertEquals(name, actualRequest.getName());
1326     Assert.assertTrue(
1327         channelProvider.isHeaderSent(
1328             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1329             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1330   }
1331 
1332   @Test
exportRegistrationExceptionTest2()1333   public void exportRegistrationExceptionTest2() throws Exception {
1334     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1335     mockDomains.addException(exception);
1336 
1337     try {
1338       String name = "name3373707";
1339       client.exportRegistrationAsync(name).get();
1340       Assert.fail("No exception raised");
1341     } catch (ExecutionException e) {
1342       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1343       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1344       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1345     }
1346   }
1347 
1348   @Test
deleteRegistrationTest()1349   public void deleteRegistrationTest() throws Exception {
1350     Empty expectedResponse = Empty.newBuilder().build();
1351     Operation resultOperation =
1352         Operation.newBuilder()
1353             .setName("deleteRegistrationTest")
1354             .setDone(true)
1355             .setResponse(Any.pack(expectedResponse))
1356             .build();
1357     mockDomains.addResponse(resultOperation);
1358 
1359     RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1360 
1361     client.deleteRegistrationAsync(name).get();
1362 
1363     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1364     Assert.assertEquals(1, actualRequests.size());
1365     DeleteRegistrationRequest actualRequest = ((DeleteRegistrationRequest) actualRequests.get(0));
1366 
1367     Assert.assertEquals(name.toString(), actualRequest.getName());
1368     Assert.assertTrue(
1369         channelProvider.isHeaderSent(
1370             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1371             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1372   }
1373 
1374   @Test
deleteRegistrationExceptionTest()1375   public void deleteRegistrationExceptionTest() throws Exception {
1376     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1377     mockDomains.addException(exception);
1378 
1379     try {
1380       RegistrationName name = RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1381       client.deleteRegistrationAsync(name).get();
1382       Assert.fail("No exception raised");
1383     } catch (ExecutionException e) {
1384       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1385       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1386       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1387     }
1388   }
1389 
1390   @Test
deleteRegistrationTest2()1391   public void deleteRegistrationTest2() throws Exception {
1392     Empty expectedResponse = Empty.newBuilder().build();
1393     Operation resultOperation =
1394         Operation.newBuilder()
1395             .setName("deleteRegistrationTest")
1396             .setDone(true)
1397             .setResponse(Any.pack(expectedResponse))
1398             .build();
1399     mockDomains.addResponse(resultOperation);
1400 
1401     String name = "name3373707";
1402 
1403     client.deleteRegistrationAsync(name).get();
1404 
1405     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1406     Assert.assertEquals(1, actualRequests.size());
1407     DeleteRegistrationRequest actualRequest = ((DeleteRegistrationRequest) actualRequests.get(0));
1408 
1409     Assert.assertEquals(name, actualRequest.getName());
1410     Assert.assertTrue(
1411         channelProvider.isHeaderSent(
1412             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1413             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1414   }
1415 
1416   @Test
deleteRegistrationExceptionTest2()1417   public void deleteRegistrationExceptionTest2() throws Exception {
1418     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1419     mockDomains.addException(exception);
1420 
1421     try {
1422       String name = "name3373707";
1423       client.deleteRegistrationAsync(name).get();
1424       Assert.fail("No exception raised");
1425     } catch (ExecutionException e) {
1426       Assert.assertEquals(InvalidArgumentException.class, e.getCause().getClass());
1427       InvalidArgumentException apiException = ((InvalidArgumentException) e.getCause());
1428       Assert.assertEquals(StatusCode.Code.INVALID_ARGUMENT, apiException.getStatusCode().getCode());
1429     }
1430   }
1431 
1432   @Test
retrieveAuthorizationCodeTest()1433   public void retrieveAuthorizationCodeTest() throws Exception {
1434     AuthorizationCode expectedResponse =
1435         AuthorizationCode.newBuilder().setCode("code3059181").build();
1436     mockDomains.addResponse(expectedResponse);
1437 
1438     RegistrationName registration =
1439         RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1440 
1441     AuthorizationCode actualResponse = client.retrieveAuthorizationCode(registration);
1442     Assert.assertEquals(expectedResponse, actualResponse);
1443 
1444     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1445     Assert.assertEquals(1, actualRequests.size());
1446     RetrieveAuthorizationCodeRequest actualRequest =
1447         ((RetrieveAuthorizationCodeRequest) actualRequests.get(0));
1448 
1449     Assert.assertEquals(registration.toString(), actualRequest.getRegistration());
1450     Assert.assertTrue(
1451         channelProvider.isHeaderSent(
1452             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1453             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1454   }
1455 
1456   @Test
retrieveAuthorizationCodeExceptionTest()1457   public void retrieveAuthorizationCodeExceptionTest() throws Exception {
1458     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1459     mockDomains.addException(exception);
1460 
1461     try {
1462       RegistrationName registration =
1463           RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1464       client.retrieveAuthorizationCode(registration);
1465       Assert.fail("No exception raised");
1466     } catch (InvalidArgumentException e) {
1467       // Expected exception.
1468     }
1469   }
1470 
1471   @Test
retrieveAuthorizationCodeTest2()1472   public void retrieveAuthorizationCodeTest2() throws Exception {
1473     AuthorizationCode expectedResponse =
1474         AuthorizationCode.newBuilder().setCode("code3059181").build();
1475     mockDomains.addResponse(expectedResponse);
1476 
1477     String registration = "registration-1350309703";
1478 
1479     AuthorizationCode actualResponse = client.retrieveAuthorizationCode(registration);
1480     Assert.assertEquals(expectedResponse, actualResponse);
1481 
1482     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1483     Assert.assertEquals(1, actualRequests.size());
1484     RetrieveAuthorizationCodeRequest actualRequest =
1485         ((RetrieveAuthorizationCodeRequest) actualRequests.get(0));
1486 
1487     Assert.assertEquals(registration, actualRequest.getRegistration());
1488     Assert.assertTrue(
1489         channelProvider.isHeaderSent(
1490             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1491             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1492   }
1493 
1494   @Test
retrieveAuthorizationCodeExceptionTest2()1495   public void retrieveAuthorizationCodeExceptionTest2() throws Exception {
1496     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1497     mockDomains.addException(exception);
1498 
1499     try {
1500       String registration = "registration-1350309703";
1501       client.retrieveAuthorizationCode(registration);
1502       Assert.fail("No exception raised");
1503     } catch (InvalidArgumentException e) {
1504       // Expected exception.
1505     }
1506   }
1507 
1508   @Test
resetAuthorizationCodeTest()1509   public void resetAuthorizationCodeTest() throws Exception {
1510     AuthorizationCode expectedResponse =
1511         AuthorizationCode.newBuilder().setCode("code3059181").build();
1512     mockDomains.addResponse(expectedResponse);
1513 
1514     RegistrationName registration =
1515         RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1516 
1517     AuthorizationCode actualResponse = client.resetAuthorizationCode(registration);
1518     Assert.assertEquals(expectedResponse, actualResponse);
1519 
1520     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1521     Assert.assertEquals(1, actualRequests.size());
1522     ResetAuthorizationCodeRequest actualRequest =
1523         ((ResetAuthorizationCodeRequest) actualRequests.get(0));
1524 
1525     Assert.assertEquals(registration.toString(), actualRequest.getRegistration());
1526     Assert.assertTrue(
1527         channelProvider.isHeaderSent(
1528             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1529             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1530   }
1531 
1532   @Test
resetAuthorizationCodeExceptionTest()1533   public void resetAuthorizationCodeExceptionTest() throws Exception {
1534     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1535     mockDomains.addException(exception);
1536 
1537     try {
1538       RegistrationName registration =
1539           RegistrationName.of("[PROJECT]", "[LOCATION]", "[REGISTRATION]");
1540       client.resetAuthorizationCode(registration);
1541       Assert.fail("No exception raised");
1542     } catch (InvalidArgumentException e) {
1543       // Expected exception.
1544     }
1545   }
1546 
1547   @Test
resetAuthorizationCodeTest2()1548   public void resetAuthorizationCodeTest2() throws Exception {
1549     AuthorizationCode expectedResponse =
1550         AuthorizationCode.newBuilder().setCode("code3059181").build();
1551     mockDomains.addResponse(expectedResponse);
1552 
1553     String registration = "registration-1350309703";
1554 
1555     AuthorizationCode actualResponse = client.resetAuthorizationCode(registration);
1556     Assert.assertEquals(expectedResponse, actualResponse);
1557 
1558     List<AbstractMessage> actualRequests = mockDomains.getRequests();
1559     Assert.assertEquals(1, actualRequests.size());
1560     ResetAuthorizationCodeRequest actualRequest =
1561         ((ResetAuthorizationCodeRequest) actualRequests.get(0));
1562 
1563     Assert.assertEquals(registration, actualRequest.getRegistration());
1564     Assert.assertTrue(
1565         channelProvider.isHeaderSent(
1566             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1567             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1568   }
1569 
1570   @Test
resetAuthorizationCodeExceptionTest2()1571   public void resetAuthorizationCodeExceptionTest2() throws Exception {
1572     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1573     mockDomains.addException(exception);
1574 
1575     try {
1576       String registration = "registration-1350309703";
1577       client.resetAuthorizationCode(registration);
1578       Assert.fail("No exception raised");
1579     } catch (InvalidArgumentException e) {
1580       // Expected exception.
1581     }
1582   }
1583 }
1584