• 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.api.serviceusage.v1beta1;
18 
19 import static com.google.api.serviceusage.v1beta1.ServiceUsageClient.ListAdminOverridesPagedResponse;
20 import static com.google.api.serviceusage.v1beta1.ServiceUsageClient.ListConsumerOverridesPagedResponse;
21 import static com.google.api.serviceusage.v1beta1.ServiceUsageClient.ListConsumerQuotaMetricsPagedResponse;
22 import static com.google.api.serviceusage.v1beta1.ServiceUsageClient.ListServicesPagedResponse;
23 
24 import com.google.api.gax.core.NoCredentialsProvider;
25 import com.google.api.gax.httpjson.GaxHttpJsonProperties;
26 import com.google.api.gax.httpjson.testing.MockHttpService;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.ApiException;
29 import com.google.api.gax.rpc.ApiExceptionFactory;
30 import com.google.api.gax.rpc.InvalidArgumentException;
31 import com.google.api.gax.rpc.StatusCode;
32 import com.google.api.gax.rpc.testing.FakeStatusCode;
33 import com.google.api.serviceusage.v1beta1.stub.HttpJsonServiceUsageStub;
34 import com.google.common.collect.Lists;
35 import com.google.longrunning.Operation;
36 import com.google.protobuf.Any;
37 import com.google.protobuf.Empty;
38 import com.google.protobuf.FieldMask;
39 import java.io.IOException;
40 import java.util.ArrayList;
41 import java.util.Arrays;
42 import java.util.HashMap;
43 import java.util.List;
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 ServiceUsageClientHttpJsonTest {
55   private static MockHttpService mockService;
56   private static ServiceUsageClient client;
57 
58   @BeforeClass
startStaticServer()59   public static void startStaticServer() throws IOException {
60     mockService =
61         new MockHttpService(
62             HttpJsonServiceUsageStub.getMethodDescriptors(),
63             ServiceUsageSettings.getDefaultEndpoint());
64     ServiceUsageSettings settings =
65         ServiceUsageSettings.newHttpJsonBuilder()
66             .setTransportChannelProvider(
67                 ServiceUsageSettings.defaultHttpJsonTransportProviderBuilder()
68                     .setHttpTransport(mockService)
69                     .build())
70             .setCredentialsProvider(NoCredentialsProvider.create())
71             .build();
72     client = ServiceUsageClient.create(settings);
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     client.close();
78   }
79 
80   @Before
setUp()81   public void setUp() {}
82 
83   @After
tearDown()84   public void tearDown() throws Exception {
85     mockService.reset();
86   }
87 
88   @Test
enableServiceTest()89   public void enableServiceTest() throws Exception {
90     Empty expectedResponse = Empty.newBuilder().build();
91     Operation resultOperation =
92         Operation.newBuilder()
93             .setName("enableServiceTest")
94             .setDone(true)
95             .setResponse(Any.pack(expectedResponse))
96             .build();
97     mockService.addResponse(resultOperation);
98 
99     EnableServiceRequest request =
100         EnableServiceRequest.newBuilder()
101             .setName("name-7410/name-7410/services/service-7410")
102             .build();
103 
104     client.enableServiceAsync(request).get();
105 
106     List<String> actualRequests = mockService.getRequestPaths();
107     Assert.assertEquals(1, actualRequests.size());
108 
109     String apiClientHeaderKey =
110         mockService
111             .getRequestHeaders()
112             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
113             .iterator()
114             .next();
115     Assert.assertTrue(
116         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
117             .matcher(apiClientHeaderKey)
118             .matches());
119   }
120 
121   @Test
enableServiceExceptionTest()122   public void enableServiceExceptionTest() throws Exception {
123     ApiException exception =
124         ApiExceptionFactory.createException(
125             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
126     mockService.addException(exception);
127 
128     try {
129       EnableServiceRequest request =
130           EnableServiceRequest.newBuilder()
131               .setName("name-7410/name-7410/services/service-7410")
132               .build();
133       client.enableServiceAsync(request).get();
134       Assert.fail("No exception raised");
135     } catch (ExecutionException e) {
136     }
137   }
138 
139   @Test
disableServiceTest()140   public void disableServiceTest() throws Exception {
141     Empty expectedResponse = Empty.newBuilder().build();
142     Operation resultOperation =
143         Operation.newBuilder()
144             .setName("disableServiceTest")
145             .setDone(true)
146             .setResponse(Any.pack(expectedResponse))
147             .build();
148     mockService.addResponse(resultOperation);
149 
150     DisableServiceRequest request =
151         DisableServiceRequest.newBuilder()
152             .setName("name-7410/name-7410/services/service-7410")
153             .build();
154 
155     client.disableServiceAsync(request).get();
156 
157     List<String> actualRequests = mockService.getRequestPaths();
158     Assert.assertEquals(1, actualRequests.size());
159 
160     String apiClientHeaderKey =
161         mockService
162             .getRequestHeaders()
163             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
164             .iterator()
165             .next();
166     Assert.assertTrue(
167         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
168             .matcher(apiClientHeaderKey)
169             .matches());
170   }
171 
172   @Test
disableServiceExceptionTest()173   public void disableServiceExceptionTest() throws Exception {
174     ApiException exception =
175         ApiExceptionFactory.createException(
176             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
177     mockService.addException(exception);
178 
179     try {
180       DisableServiceRequest request =
181           DisableServiceRequest.newBuilder()
182               .setName("name-7410/name-7410/services/service-7410")
183               .build();
184       client.disableServiceAsync(request).get();
185       Assert.fail("No exception raised");
186     } catch (ExecutionException e) {
187     }
188   }
189 
190   @Test
getServiceTest()191   public void getServiceTest() throws Exception {
192     Service expectedResponse =
193         Service.newBuilder()
194             .setName("name3373707")
195             .setParent("parent-995424086")
196             .setConfig(ServiceConfig.newBuilder().build())
197             .setState(State.forNumber(0))
198             .build();
199     mockService.addResponse(expectedResponse);
200 
201     GetServiceRequest request =
202         GetServiceRequest.newBuilder().setName("name-7410/name-7410/services/service-7410").build();
203 
204     Service actualResponse = client.getService(request);
205     Assert.assertEquals(expectedResponse, actualResponse);
206 
207     List<String> actualRequests = mockService.getRequestPaths();
208     Assert.assertEquals(1, actualRequests.size());
209 
210     String apiClientHeaderKey =
211         mockService
212             .getRequestHeaders()
213             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
214             .iterator()
215             .next();
216     Assert.assertTrue(
217         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
218             .matcher(apiClientHeaderKey)
219             .matches());
220   }
221 
222   @Test
getServiceExceptionTest()223   public void getServiceExceptionTest() throws Exception {
224     ApiException exception =
225         ApiExceptionFactory.createException(
226             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
227     mockService.addException(exception);
228 
229     try {
230       GetServiceRequest request =
231           GetServiceRequest.newBuilder()
232               .setName("name-7410/name-7410/services/service-7410")
233               .build();
234       client.getService(request);
235       Assert.fail("No exception raised");
236     } catch (InvalidArgumentException e) {
237       // Expected exception.
238     }
239   }
240 
241   @Test
listServicesTest()242   public void listServicesTest() throws Exception {
243     Service responsesElement = Service.newBuilder().build();
244     ListServicesResponse expectedResponse =
245         ListServicesResponse.newBuilder()
246             .setNextPageToken("")
247             .addAllServices(Arrays.asList(responsesElement))
248             .build();
249     mockService.addResponse(expectedResponse);
250 
251     ListServicesRequest request =
252         ListServicesRequest.newBuilder()
253             .setParent("parent-4715/parent-4715")
254             .setPageSize(883849137)
255             .setPageToken("pageToken873572522")
256             .setFilter("filter-1274492040")
257             .build();
258 
259     ListServicesPagedResponse pagedListResponse = client.listServices(request);
260 
261     List<Service> resources = Lists.newArrayList(pagedListResponse.iterateAll());
262 
263     Assert.assertEquals(1, resources.size());
264     Assert.assertEquals(expectedResponse.getServicesList().get(0), resources.get(0));
265 
266     List<String> actualRequests = mockService.getRequestPaths();
267     Assert.assertEquals(1, actualRequests.size());
268 
269     String apiClientHeaderKey =
270         mockService
271             .getRequestHeaders()
272             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
273             .iterator()
274             .next();
275     Assert.assertTrue(
276         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
277             .matcher(apiClientHeaderKey)
278             .matches());
279   }
280 
281   @Test
listServicesExceptionTest()282   public void listServicesExceptionTest() throws Exception {
283     ApiException exception =
284         ApiExceptionFactory.createException(
285             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
286     mockService.addException(exception);
287 
288     try {
289       ListServicesRequest request =
290           ListServicesRequest.newBuilder()
291               .setParent("parent-4715/parent-4715")
292               .setPageSize(883849137)
293               .setPageToken("pageToken873572522")
294               .setFilter("filter-1274492040")
295               .build();
296       client.listServices(request);
297       Assert.fail("No exception raised");
298     } catch (InvalidArgumentException e) {
299       // Expected exception.
300     }
301   }
302 
303   @Test
batchEnableServicesTest()304   public void batchEnableServicesTest() throws Exception {
305     Empty expectedResponse = Empty.newBuilder().build();
306     Operation resultOperation =
307         Operation.newBuilder()
308             .setName("batchEnableServicesTest")
309             .setDone(true)
310             .setResponse(Any.pack(expectedResponse))
311             .build();
312     mockService.addResponse(resultOperation);
313 
314     BatchEnableServicesRequest request =
315         BatchEnableServicesRequest.newBuilder()
316             .setParent("parent-4715/parent-4715")
317             .addAllServiceIds(new ArrayList<String>())
318             .build();
319 
320     client.batchEnableServicesAsync(request).get();
321 
322     List<String> actualRequests = mockService.getRequestPaths();
323     Assert.assertEquals(1, actualRequests.size());
324 
325     String apiClientHeaderKey =
326         mockService
327             .getRequestHeaders()
328             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
329             .iterator()
330             .next();
331     Assert.assertTrue(
332         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
333             .matcher(apiClientHeaderKey)
334             .matches());
335   }
336 
337   @Test
batchEnableServicesExceptionTest()338   public void batchEnableServicesExceptionTest() throws Exception {
339     ApiException exception =
340         ApiExceptionFactory.createException(
341             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
342     mockService.addException(exception);
343 
344     try {
345       BatchEnableServicesRequest request =
346           BatchEnableServicesRequest.newBuilder()
347               .setParent("parent-4715/parent-4715")
348               .addAllServiceIds(new ArrayList<String>())
349               .build();
350       client.batchEnableServicesAsync(request).get();
351       Assert.fail("No exception raised");
352     } catch (ExecutionException e) {
353     }
354   }
355 
356   @Test
listConsumerQuotaMetricsTest()357   public void listConsumerQuotaMetricsTest() throws Exception {
358     ConsumerQuotaMetric responsesElement = ConsumerQuotaMetric.newBuilder().build();
359     ListConsumerQuotaMetricsResponse expectedResponse =
360         ListConsumerQuotaMetricsResponse.newBuilder()
361             .setNextPageToken("")
362             .addAllMetrics(Arrays.asList(responsesElement))
363             .build();
364     mockService.addResponse(expectedResponse);
365 
366     ListConsumerQuotaMetricsRequest request =
367         ListConsumerQuotaMetricsRequest.newBuilder()
368             .setParent("parent-2637/parent-2637/services/service-2637")
369             .setPageSize(883849137)
370             .setPageToken("pageToken873572522")
371             .setView(QuotaView.forNumber(0))
372             .build();
373 
374     ListConsumerQuotaMetricsPagedResponse pagedListResponse =
375         client.listConsumerQuotaMetrics(request);
376 
377     List<ConsumerQuotaMetric> resources = Lists.newArrayList(pagedListResponse.iterateAll());
378 
379     Assert.assertEquals(1, resources.size());
380     Assert.assertEquals(expectedResponse.getMetricsList().get(0), resources.get(0));
381 
382     List<String> actualRequests = mockService.getRequestPaths();
383     Assert.assertEquals(1, actualRequests.size());
384 
385     String apiClientHeaderKey =
386         mockService
387             .getRequestHeaders()
388             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
389             .iterator()
390             .next();
391     Assert.assertTrue(
392         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
393             .matcher(apiClientHeaderKey)
394             .matches());
395   }
396 
397   @Test
listConsumerQuotaMetricsExceptionTest()398   public void listConsumerQuotaMetricsExceptionTest() throws Exception {
399     ApiException exception =
400         ApiExceptionFactory.createException(
401             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
402     mockService.addException(exception);
403 
404     try {
405       ListConsumerQuotaMetricsRequest request =
406           ListConsumerQuotaMetricsRequest.newBuilder()
407               .setParent("parent-2637/parent-2637/services/service-2637")
408               .setPageSize(883849137)
409               .setPageToken("pageToken873572522")
410               .setView(QuotaView.forNumber(0))
411               .build();
412       client.listConsumerQuotaMetrics(request);
413       Assert.fail("No exception raised");
414     } catch (InvalidArgumentException e) {
415       // Expected exception.
416     }
417   }
418 
419   @Test
getConsumerQuotaMetricTest()420   public void getConsumerQuotaMetricTest() throws Exception {
421     ConsumerQuotaMetric expectedResponse =
422         ConsumerQuotaMetric.newBuilder()
423             .setName("name3373707")
424             .setMetric("metric-1077545552")
425             .setDisplayName("displayName1714148973")
426             .addAllConsumerQuotaLimits(new ArrayList<ConsumerQuotaLimit>())
427             .addAllDescendantConsumerQuotaLimits(new ArrayList<ConsumerQuotaLimit>())
428             .setUnit("unit3594628")
429             .build();
430     mockService.addResponse(expectedResponse);
431 
432     GetConsumerQuotaMetricRequest request =
433         GetConsumerQuotaMetricRequest.newBuilder()
434             .setName(
435                 "name-5949/name-5949/services/service-5949/consumerQuotaMetrics/consumerQuotaMetric-5949")
436             .setView(QuotaView.forNumber(0))
437             .build();
438 
439     ConsumerQuotaMetric actualResponse = client.getConsumerQuotaMetric(request);
440     Assert.assertEquals(expectedResponse, actualResponse);
441 
442     List<String> actualRequests = mockService.getRequestPaths();
443     Assert.assertEquals(1, actualRequests.size());
444 
445     String apiClientHeaderKey =
446         mockService
447             .getRequestHeaders()
448             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
449             .iterator()
450             .next();
451     Assert.assertTrue(
452         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
453             .matcher(apiClientHeaderKey)
454             .matches());
455   }
456 
457   @Test
getConsumerQuotaMetricExceptionTest()458   public void getConsumerQuotaMetricExceptionTest() throws Exception {
459     ApiException exception =
460         ApiExceptionFactory.createException(
461             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
462     mockService.addException(exception);
463 
464     try {
465       GetConsumerQuotaMetricRequest request =
466           GetConsumerQuotaMetricRequest.newBuilder()
467               .setName(
468                   "name-5949/name-5949/services/service-5949/consumerQuotaMetrics/consumerQuotaMetric-5949")
469               .setView(QuotaView.forNumber(0))
470               .build();
471       client.getConsumerQuotaMetric(request);
472       Assert.fail("No exception raised");
473     } catch (InvalidArgumentException e) {
474       // Expected exception.
475     }
476   }
477 
478   @Test
getConsumerQuotaLimitTest()479   public void getConsumerQuotaLimitTest() throws Exception {
480     ConsumerQuotaLimit expectedResponse =
481         ConsumerQuotaLimit.newBuilder()
482             .setName("name3373707")
483             .setMetric("metric-1077545552")
484             .setUnit("unit3594628")
485             .setIsPrecise(true)
486             .setAllowsAdminOverrides(true)
487             .addAllQuotaBuckets(new ArrayList<QuotaBucket>())
488             .build();
489     mockService.addResponse(expectedResponse);
490 
491     GetConsumerQuotaLimitRequest request =
492         GetConsumerQuotaLimitRequest.newBuilder()
493             .setName(
494                 "name-6379/name-6379/services/service-6379/consumerQuotaMetrics/consumerQuotaMetric-6379/limits/limit-6379")
495             .setView(QuotaView.forNumber(0))
496             .build();
497 
498     ConsumerQuotaLimit actualResponse = client.getConsumerQuotaLimit(request);
499     Assert.assertEquals(expectedResponse, actualResponse);
500 
501     List<String> actualRequests = mockService.getRequestPaths();
502     Assert.assertEquals(1, actualRequests.size());
503 
504     String apiClientHeaderKey =
505         mockService
506             .getRequestHeaders()
507             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
508             .iterator()
509             .next();
510     Assert.assertTrue(
511         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
512             .matcher(apiClientHeaderKey)
513             .matches());
514   }
515 
516   @Test
getConsumerQuotaLimitExceptionTest()517   public void getConsumerQuotaLimitExceptionTest() throws Exception {
518     ApiException exception =
519         ApiExceptionFactory.createException(
520             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
521     mockService.addException(exception);
522 
523     try {
524       GetConsumerQuotaLimitRequest request =
525           GetConsumerQuotaLimitRequest.newBuilder()
526               .setName(
527                   "name-6379/name-6379/services/service-6379/consumerQuotaMetrics/consumerQuotaMetric-6379/limits/limit-6379")
528               .setView(QuotaView.forNumber(0))
529               .build();
530       client.getConsumerQuotaLimit(request);
531       Assert.fail("No exception raised");
532     } catch (InvalidArgumentException e) {
533       // Expected exception.
534     }
535   }
536 
537   @Test
createAdminOverrideTest()538   public void createAdminOverrideTest() throws Exception {
539     QuotaOverride expectedResponse =
540         QuotaOverride.newBuilder()
541             .setName("name3373707")
542             .setOverrideValue(-355006658)
543             .putAllDimensions(new HashMap<String, String>())
544             .setMetric("metric-1077545552")
545             .setUnit("unit3594628")
546             .setAdminOverrideAncestor("adminOverrideAncestor-1443674322")
547             .build();
548     Operation resultOperation =
549         Operation.newBuilder()
550             .setName("createAdminOverrideTest")
551             .setDone(true)
552             .setResponse(Any.pack(expectedResponse))
553             .build();
554     mockService.addResponse(resultOperation);
555 
556     CreateAdminOverrideRequest request =
557         CreateAdminOverrideRequest.newBuilder()
558             .setParent(
559                 "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
560             .setOverride(QuotaOverride.newBuilder().build())
561             .setForce(true)
562             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
563             .build();
564 
565     QuotaOverride actualResponse = client.createAdminOverrideAsync(request).get();
566     Assert.assertEquals(expectedResponse, actualResponse);
567 
568     List<String> actualRequests = mockService.getRequestPaths();
569     Assert.assertEquals(1, actualRequests.size());
570 
571     String apiClientHeaderKey =
572         mockService
573             .getRequestHeaders()
574             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
575             .iterator()
576             .next();
577     Assert.assertTrue(
578         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
579             .matcher(apiClientHeaderKey)
580             .matches());
581   }
582 
583   @Test
createAdminOverrideExceptionTest()584   public void createAdminOverrideExceptionTest() throws Exception {
585     ApiException exception =
586         ApiExceptionFactory.createException(
587             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
588     mockService.addException(exception);
589 
590     try {
591       CreateAdminOverrideRequest request =
592           CreateAdminOverrideRequest.newBuilder()
593               .setParent(
594                   "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
595               .setOverride(QuotaOverride.newBuilder().build())
596               .setForce(true)
597               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
598               .build();
599       client.createAdminOverrideAsync(request).get();
600       Assert.fail("No exception raised");
601     } catch (ExecutionException e) {
602     }
603   }
604 
605   @Test
updateAdminOverrideTest()606   public void updateAdminOverrideTest() throws Exception {
607     QuotaOverride expectedResponse =
608         QuotaOverride.newBuilder()
609             .setName("name3373707")
610             .setOverrideValue(-355006658)
611             .putAllDimensions(new HashMap<String, String>())
612             .setMetric("metric-1077545552")
613             .setUnit("unit3594628")
614             .setAdminOverrideAncestor("adminOverrideAncestor-1443674322")
615             .build();
616     Operation resultOperation =
617         Operation.newBuilder()
618             .setName("updateAdminOverrideTest")
619             .setDone(true)
620             .setResponse(Any.pack(expectedResponse))
621             .build();
622     mockService.addResponse(resultOperation);
623 
624     UpdateAdminOverrideRequest request =
625         UpdateAdminOverrideRequest.newBuilder()
626             .setName(
627                 "name-9389/name-9389/services/service-9389/consumerQuotaMetrics/consumerQuotaMetric-9389/limits/limit-9389/adminOverrides/adminOverride-9389")
628             .setOverride(QuotaOverride.newBuilder().build())
629             .setForce(true)
630             .setUpdateMask(FieldMask.newBuilder().build())
631             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
632             .build();
633 
634     QuotaOverride actualResponse = client.updateAdminOverrideAsync(request).get();
635     Assert.assertEquals(expectedResponse, actualResponse);
636 
637     List<String> actualRequests = mockService.getRequestPaths();
638     Assert.assertEquals(1, actualRequests.size());
639 
640     String apiClientHeaderKey =
641         mockService
642             .getRequestHeaders()
643             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
644             .iterator()
645             .next();
646     Assert.assertTrue(
647         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
648             .matcher(apiClientHeaderKey)
649             .matches());
650   }
651 
652   @Test
updateAdminOverrideExceptionTest()653   public void updateAdminOverrideExceptionTest() throws Exception {
654     ApiException exception =
655         ApiExceptionFactory.createException(
656             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
657     mockService.addException(exception);
658 
659     try {
660       UpdateAdminOverrideRequest request =
661           UpdateAdminOverrideRequest.newBuilder()
662               .setName(
663                   "name-9389/name-9389/services/service-9389/consumerQuotaMetrics/consumerQuotaMetric-9389/limits/limit-9389/adminOverrides/adminOverride-9389")
664               .setOverride(QuotaOverride.newBuilder().build())
665               .setForce(true)
666               .setUpdateMask(FieldMask.newBuilder().build())
667               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
668               .build();
669       client.updateAdminOverrideAsync(request).get();
670       Assert.fail("No exception raised");
671     } catch (ExecutionException e) {
672     }
673   }
674 
675   @Test
deleteAdminOverrideTest()676   public void deleteAdminOverrideTest() throws Exception {
677     Empty expectedResponse = Empty.newBuilder().build();
678     Operation resultOperation =
679         Operation.newBuilder()
680             .setName("deleteAdminOverrideTest")
681             .setDone(true)
682             .setResponse(Any.pack(expectedResponse))
683             .build();
684     mockService.addResponse(resultOperation);
685 
686     DeleteAdminOverrideRequest request =
687         DeleteAdminOverrideRequest.newBuilder()
688             .setName(
689                 "name-9389/name-9389/services/service-9389/consumerQuotaMetrics/consumerQuotaMetric-9389/limits/limit-9389/adminOverrides/adminOverride-9389")
690             .setForce(true)
691             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
692             .build();
693 
694     client.deleteAdminOverrideAsync(request).get();
695 
696     List<String> actualRequests = mockService.getRequestPaths();
697     Assert.assertEquals(1, actualRequests.size());
698 
699     String apiClientHeaderKey =
700         mockService
701             .getRequestHeaders()
702             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
703             .iterator()
704             .next();
705     Assert.assertTrue(
706         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
707             .matcher(apiClientHeaderKey)
708             .matches());
709   }
710 
711   @Test
deleteAdminOverrideExceptionTest()712   public void deleteAdminOverrideExceptionTest() throws Exception {
713     ApiException exception =
714         ApiExceptionFactory.createException(
715             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
716     mockService.addException(exception);
717 
718     try {
719       DeleteAdminOverrideRequest request =
720           DeleteAdminOverrideRequest.newBuilder()
721               .setName(
722                   "name-9389/name-9389/services/service-9389/consumerQuotaMetrics/consumerQuotaMetric-9389/limits/limit-9389/adminOverrides/adminOverride-9389")
723               .setForce(true)
724               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
725               .build();
726       client.deleteAdminOverrideAsync(request).get();
727       Assert.fail("No exception raised");
728     } catch (ExecutionException e) {
729     }
730   }
731 
732   @Test
listAdminOverridesTest()733   public void listAdminOverridesTest() throws Exception {
734     QuotaOverride responsesElement = QuotaOverride.newBuilder().build();
735     ListAdminOverridesResponse expectedResponse =
736         ListAdminOverridesResponse.newBuilder()
737             .setNextPageToken("")
738             .addAllOverrides(Arrays.asList(responsesElement))
739             .build();
740     mockService.addResponse(expectedResponse);
741 
742     ListAdminOverridesRequest request =
743         ListAdminOverridesRequest.newBuilder()
744             .setParent(
745                 "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
746             .setPageSize(883849137)
747             .setPageToken("pageToken873572522")
748             .build();
749 
750     ListAdminOverridesPagedResponse pagedListResponse = client.listAdminOverrides(request);
751 
752     List<QuotaOverride> resources = Lists.newArrayList(pagedListResponse.iterateAll());
753 
754     Assert.assertEquals(1, resources.size());
755     Assert.assertEquals(expectedResponse.getOverridesList().get(0), resources.get(0));
756 
757     List<String> actualRequests = mockService.getRequestPaths();
758     Assert.assertEquals(1, actualRequests.size());
759 
760     String apiClientHeaderKey =
761         mockService
762             .getRequestHeaders()
763             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
764             .iterator()
765             .next();
766     Assert.assertTrue(
767         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
768             .matcher(apiClientHeaderKey)
769             .matches());
770   }
771 
772   @Test
listAdminOverridesExceptionTest()773   public void listAdminOverridesExceptionTest() throws Exception {
774     ApiException exception =
775         ApiExceptionFactory.createException(
776             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
777     mockService.addException(exception);
778 
779     try {
780       ListAdminOverridesRequest request =
781           ListAdminOverridesRequest.newBuilder()
782               .setParent(
783                   "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
784               .setPageSize(883849137)
785               .setPageToken("pageToken873572522")
786               .build();
787       client.listAdminOverrides(request);
788       Assert.fail("No exception raised");
789     } catch (InvalidArgumentException e) {
790       // Expected exception.
791     }
792   }
793 
794   @Test
importAdminOverridesTest()795   public void importAdminOverridesTest() throws Exception {
796     ImportAdminOverridesResponse expectedResponse =
797         ImportAdminOverridesResponse.newBuilder()
798             .addAllOverrides(new ArrayList<QuotaOverride>())
799             .build();
800     Operation resultOperation =
801         Operation.newBuilder()
802             .setName("importAdminOverridesTest")
803             .setDone(true)
804             .setResponse(Any.pack(expectedResponse))
805             .build();
806     mockService.addResponse(resultOperation);
807 
808     ImportAdminOverridesRequest request =
809         ImportAdminOverridesRequest.newBuilder()
810             .setParent("parent-2637/parent-2637/services/service-2637")
811             .setForce(true)
812             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
813             .build();
814 
815     ImportAdminOverridesResponse actualResponse = client.importAdminOverridesAsync(request).get();
816     Assert.assertEquals(expectedResponse, actualResponse);
817 
818     List<String> actualRequests = mockService.getRequestPaths();
819     Assert.assertEquals(1, actualRequests.size());
820 
821     String apiClientHeaderKey =
822         mockService
823             .getRequestHeaders()
824             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
825             .iterator()
826             .next();
827     Assert.assertTrue(
828         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
829             .matcher(apiClientHeaderKey)
830             .matches());
831   }
832 
833   @Test
importAdminOverridesExceptionTest()834   public void importAdminOverridesExceptionTest() throws Exception {
835     ApiException exception =
836         ApiExceptionFactory.createException(
837             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
838     mockService.addException(exception);
839 
840     try {
841       ImportAdminOverridesRequest request =
842           ImportAdminOverridesRequest.newBuilder()
843               .setParent("parent-2637/parent-2637/services/service-2637")
844               .setForce(true)
845               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
846               .build();
847       client.importAdminOverridesAsync(request).get();
848       Assert.fail("No exception raised");
849     } catch (ExecutionException e) {
850     }
851   }
852 
853   @Test
createConsumerOverrideTest()854   public void createConsumerOverrideTest() throws Exception {
855     QuotaOverride expectedResponse =
856         QuotaOverride.newBuilder()
857             .setName("name3373707")
858             .setOverrideValue(-355006658)
859             .putAllDimensions(new HashMap<String, String>())
860             .setMetric("metric-1077545552")
861             .setUnit("unit3594628")
862             .setAdminOverrideAncestor("adminOverrideAncestor-1443674322")
863             .build();
864     Operation resultOperation =
865         Operation.newBuilder()
866             .setName("createConsumerOverrideTest")
867             .setDone(true)
868             .setResponse(Any.pack(expectedResponse))
869             .build();
870     mockService.addResponse(resultOperation);
871 
872     CreateConsumerOverrideRequest request =
873         CreateConsumerOverrideRequest.newBuilder()
874             .setParent(
875                 "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
876             .setOverride(QuotaOverride.newBuilder().build())
877             .setForce(true)
878             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
879             .build();
880 
881     QuotaOverride actualResponse = client.createConsumerOverrideAsync(request).get();
882     Assert.assertEquals(expectedResponse, actualResponse);
883 
884     List<String> actualRequests = mockService.getRequestPaths();
885     Assert.assertEquals(1, actualRequests.size());
886 
887     String apiClientHeaderKey =
888         mockService
889             .getRequestHeaders()
890             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
891             .iterator()
892             .next();
893     Assert.assertTrue(
894         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
895             .matcher(apiClientHeaderKey)
896             .matches());
897   }
898 
899   @Test
createConsumerOverrideExceptionTest()900   public void createConsumerOverrideExceptionTest() throws Exception {
901     ApiException exception =
902         ApiExceptionFactory.createException(
903             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
904     mockService.addException(exception);
905 
906     try {
907       CreateConsumerOverrideRequest request =
908           CreateConsumerOverrideRequest.newBuilder()
909               .setParent(
910                   "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
911               .setOverride(QuotaOverride.newBuilder().build())
912               .setForce(true)
913               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
914               .build();
915       client.createConsumerOverrideAsync(request).get();
916       Assert.fail("No exception raised");
917     } catch (ExecutionException e) {
918     }
919   }
920 
921   @Test
updateConsumerOverrideTest()922   public void updateConsumerOverrideTest() throws Exception {
923     QuotaOverride expectedResponse =
924         QuotaOverride.newBuilder()
925             .setName("name3373707")
926             .setOverrideValue(-355006658)
927             .putAllDimensions(new HashMap<String, String>())
928             .setMetric("metric-1077545552")
929             .setUnit("unit3594628")
930             .setAdminOverrideAncestor("adminOverrideAncestor-1443674322")
931             .build();
932     Operation resultOperation =
933         Operation.newBuilder()
934             .setName("updateConsumerOverrideTest")
935             .setDone(true)
936             .setResponse(Any.pack(expectedResponse))
937             .build();
938     mockService.addResponse(resultOperation);
939 
940     UpdateConsumerOverrideRequest request =
941         UpdateConsumerOverrideRequest.newBuilder()
942             .setName(
943                 "name-4498/name-4498/services/service-4498/consumerQuotaMetrics/consumerQuotaMetric-4498/limits/limit-4498/consumerOverrides/consumerOverride-4498")
944             .setOverride(QuotaOverride.newBuilder().build())
945             .setForce(true)
946             .setUpdateMask(FieldMask.newBuilder().build())
947             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
948             .build();
949 
950     QuotaOverride actualResponse = client.updateConsumerOverrideAsync(request).get();
951     Assert.assertEquals(expectedResponse, actualResponse);
952 
953     List<String> actualRequests = mockService.getRequestPaths();
954     Assert.assertEquals(1, actualRequests.size());
955 
956     String apiClientHeaderKey =
957         mockService
958             .getRequestHeaders()
959             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
960             .iterator()
961             .next();
962     Assert.assertTrue(
963         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
964             .matcher(apiClientHeaderKey)
965             .matches());
966   }
967 
968   @Test
updateConsumerOverrideExceptionTest()969   public void updateConsumerOverrideExceptionTest() throws Exception {
970     ApiException exception =
971         ApiExceptionFactory.createException(
972             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
973     mockService.addException(exception);
974 
975     try {
976       UpdateConsumerOverrideRequest request =
977           UpdateConsumerOverrideRequest.newBuilder()
978               .setName(
979                   "name-4498/name-4498/services/service-4498/consumerQuotaMetrics/consumerQuotaMetric-4498/limits/limit-4498/consumerOverrides/consumerOverride-4498")
980               .setOverride(QuotaOverride.newBuilder().build())
981               .setForce(true)
982               .setUpdateMask(FieldMask.newBuilder().build())
983               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
984               .build();
985       client.updateConsumerOverrideAsync(request).get();
986       Assert.fail("No exception raised");
987     } catch (ExecutionException e) {
988     }
989   }
990 
991   @Test
deleteConsumerOverrideTest()992   public void deleteConsumerOverrideTest() throws Exception {
993     Empty expectedResponse = Empty.newBuilder().build();
994     Operation resultOperation =
995         Operation.newBuilder()
996             .setName("deleteConsumerOverrideTest")
997             .setDone(true)
998             .setResponse(Any.pack(expectedResponse))
999             .build();
1000     mockService.addResponse(resultOperation);
1001 
1002     DeleteConsumerOverrideRequest request =
1003         DeleteConsumerOverrideRequest.newBuilder()
1004             .setName(
1005                 "name-4498/name-4498/services/service-4498/consumerQuotaMetrics/consumerQuotaMetric-4498/limits/limit-4498/consumerOverrides/consumerOverride-4498")
1006             .setForce(true)
1007             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
1008             .build();
1009 
1010     client.deleteConsumerOverrideAsync(request).get();
1011 
1012     List<String> actualRequests = mockService.getRequestPaths();
1013     Assert.assertEquals(1, actualRequests.size());
1014 
1015     String apiClientHeaderKey =
1016         mockService
1017             .getRequestHeaders()
1018             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1019             .iterator()
1020             .next();
1021     Assert.assertTrue(
1022         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1023             .matcher(apiClientHeaderKey)
1024             .matches());
1025   }
1026 
1027   @Test
deleteConsumerOverrideExceptionTest()1028   public void deleteConsumerOverrideExceptionTest() throws Exception {
1029     ApiException exception =
1030         ApiExceptionFactory.createException(
1031             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1032     mockService.addException(exception);
1033 
1034     try {
1035       DeleteConsumerOverrideRequest request =
1036           DeleteConsumerOverrideRequest.newBuilder()
1037               .setName(
1038                   "name-4498/name-4498/services/service-4498/consumerQuotaMetrics/consumerQuotaMetric-4498/limits/limit-4498/consumerOverrides/consumerOverride-4498")
1039               .setForce(true)
1040               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
1041               .build();
1042       client.deleteConsumerOverrideAsync(request).get();
1043       Assert.fail("No exception raised");
1044     } catch (ExecutionException e) {
1045     }
1046   }
1047 
1048   @Test
listConsumerOverridesTest()1049   public void listConsumerOverridesTest() throws Exception {
1050     QuotaOverride responsesElement = QuotaOverride.newBuilder().build();
1051     ListConsumerOverridesResponse expectedResponse =
1052         ListConsumerOverridesResponse.newBuilder()
1053             .setNextPageToken("")
1054             .addAllOverrides(Arrays.asList(responsesElement))
1055             .build();
1056     mockService.addResponse(expectedResponse);
1057 
1058     ListConsumerOverridesRequest request =
1059         ListConsumerOverridesRequest.newBuilder()
1060             .setParent(
1061                 "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
1062             .setPageSize(883849137)
1063             .setPageToken("pageToken873572522")
1064             .build();
1065 
1066     ListConsumerOverridesPagedResponse pagedListResponse = client.listConsumerOverrides(request);
1067 
1068     List<QuotaOverride> resources = Lists.newArrayList(pagedListResponse.iterateAll());
1069 
1070     Assert.assertEquals(1, resources.size());
1071     Assert.assertEquals(expectedResponse.getOverridesList().get(0), resources.get(0));
1072 
1073     List<String> actualRequests = mockService.getRequestPaths();
1074     Assert.assertEquals(1, actualRequests.size());
1075 
1076     String apiClientHeaderKey =
1077         mockService
1078             .getRequestHeaders()
1079             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1080             .iterator()
1081             .next();
1082     Assert.assertTrue(
1083         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1084             .matcher(apiClientHeaderKey)
1085             .matches());
1086   }
1087 
1088   @Test
listConsumerOverridesExceptionTest()1089   public void listConsumerOverridesExceptionTest() throws Exception {
1090     ApiException exception =
1091         ApiExceptionFactory.createException(
1092             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1093     mockService.addException(exception);
1094 
1095     try {
1096       ListConsumerOverridesRequest request =
1097           ListConsumerOverridesRequest.newBuilder()
1098               .setParent(
1099                   "parent-8356/parent-8356/services/service-8356/consumerQuotaMetrics/consumerQuotaMetric-8356/limits/limit-8356")
1100               .setPageSize(883849137)
1101               .setPageToken("pageToken873572522")
1102               .build();
1103       client.listConsumerOverrides(request);
1104       Assert.fail("No exception raised");
1105     } catch (InvalidArgumentException e) {
1106       // Expected exception.
1107     }
1108   }
1109 
1110   @Test
importConsumerOverridesTest()1111   public void importConsumerOverridesTest() throws Exception {
1112     ImportConsumerOverridesResponse expectedResponse =
1113         ImportConsumerOverridesResponse.newBuilder()
1114             .addAllOverrides(new ArrayList<QuotaOverride>())
1115             .build();
1116     Operation resultOperation =
1117         Operation.newBuilder()
1118             .setName("importConsumerOverridesTest")
1119             .setDone(true)
1120             .setResponse(Any.pack(expectedResponse))
1121             .build();
1122     mockService.addResponse(resultOperation);
1123 
1124     ImportConsumerOverridesRequest request =
1125         ImportConsumerOverridesRequest.newBuilder()
1126             .setParent("parent-2637/parent-2637/services/service-2637")
1127             .setForce(true)
1128             .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
1129             .build();
1130 
1131     ImportConsumerOverridesResponse actualResponse =
1132         client.importConsumerOverridesAsync(request).get();
1133     Assert.assertEquals(expectedResponse, actualResponse);
1134 
1135     List<String> actualRequests = mockService.getRequestPaths();
1136     Assert.assertEquals(1, actualRequests.size());
1137 
1138     String apiClientHeaderKey =
1139         mockService
1140             .getRequestHeaders()
1141             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1142             .iterator()
1143             .next();
1144     Assert.assertTrue(
1145         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1146             .matcher(apiClientHeaderKey)
1147             .matches());
1148   }
1149 
1150   @Test
importConsumerOverridesExceptionTest()1151   public void importConsumerOverridesExceptionTest() throws Exception {
1152     ApiException exception =
1153         ApiExceptionFactory.createException(
1154             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1155     mockService.addException(exception);
1156 
1157     try {
1158       ImportConsumerOverridesRequest request =
1159           ImportConsumerOverridesRequest.newBuilder()
1160               .setParent("parent-2637/parent-2637/services/service-2637")
1161               .setForce(true)
1162               .addAllForceOnly(new ArrayList<QuotaSafetyCheck>())
1163               .build();
1164       client.importConsumerOverridesAsync(request).get();
1165       Assert.fail("No exception raised");
1166     } catch (ExecutionException e) {
1167     }
1168   }
1169 
1170   @Test
generateServiceIdentityTest()1171   public void generateServiceIdentityTest() throws Exception {
1172     ServiceIdentity expectedResponse =
1173         ServiceIdentity.newBuilder()
1174             .setEmail("email96619420")
1175             .setUniqueId("uniqueId-294460212")
1176             .build();
1177     Operation resultOperation =
1178         Operation.newBuilder()
1179             .setName("generateServiceIdentityTest")
1180             .setDone(true)
1181             .setResponse(Any.pack(expectedResponse))
1182             .build();
1183     mockService.addResponse(resultOperation);
1184 
1185     GenerateServiceIdentityRequest request =
1186         GenerateServiceIdentityRequest.newBuilder()
1187             .setParent("parent-2637/parent-2637/services/service-2637")
1188             .build();
1189 
1190     ServiceIdentity actualResponse = client.generateServiceIdentityAsync(request).get();
1191     Assert.assertEquals(expectedResponse, actualResponse);
1192 
1193     List<String> actualRequests = mockService.getRequestPaths();
1194     Assert.assertEquals(1, actualRequests.size());
1195 
1196     String apiClientHeaderKey =
1197         mockService
1198             .getRequestHeaders()
1199             .get(ApiClientHeaderProvider.getDefaultApiClientHeaderKey())
1200             .iterator()
1201             .next();
1202     Assert.assertTrue(
1203         GaxHttpJsonProperties.getDefaultApiClientHeaderPattern()
1204             .matcher(apiClientHeaderKey)
1205             .matches());
1206   }
1207 
1208   @Test
generateServiceIdentityExceptionTest()1209   public void generateServiceIdentityExceptionTest() throws Exception {
1210     ApiException exception =
1211         ApiExceptionFactory.createException(
1212             new Exception(), FakeStatusCode.of(StatusCode.Code.INVALID_ARGUMENT), false);
1213     mockService.addException(exception);
1214 
1215     try {
1216       GenerateServiceIdentityRequest request =
1217           GenerateServiceIdentityRequest.newBuilder()
1218               .setParent("parent-2637/parent-2637/services/service-2637")
1219               .build();
1220       client.generateServiceIdentityAsync(request).get();
1221       Assert.fail("No exception raised");
1222     } catch (ExecutionException e) {
1223     }
1224   }
1225 }
1226