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