• 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.iot.v1;
18 
19 import static com.google.cloud.iot.v1.DeviceManagerClient.ListDeviceRegistriesPagedResponse;
20 import static com.google.cloud.iot.v1.DeviceManagerClient.ListDevicesPagedResponse;
21 
22 import com.google.api.gax.core.NoCredentialsProvider;
23 import com.google.api.gax.grpc.GaxGrpcProperties;
24 import com.google.api.gax.grpc.testing.LocalChannelProvider;
25 import com.google.api.gax.grpc.testing.MockGrpcService;
26 import com.google.api.gax.grpc.testing.MockServiceHelper;
27 import com.google.api.gax.rpc.ApiClientHeaderProvider;
28 import com.google.api.gax.rpc.InvalidArgumentException;
29 import com.google.api.resourcenames.ResourceName;
30 import com.google.common.collect.Lists;
31 import com.google.iam.v1.AuditConfig;
32 import com.google.iam.v1.Binding;
33 import com.google.iam.v1.GetIamPolicyRequest;
34 import com.google.iam.v1.Policy;
35 import com.google.iam.v1.SetIamPolicyRequest;
36 import com.google.iam.v1.TestIamPermissionsRequest;
37 import com.google.iam.v1.TestIamPermissionsResponse;
38 import com.google.protobuf.AbstractMessage;
39 import com.google.protobuf.ByteString;
40 import com.google.protobuf.Empty;
41 import com.google.protobuf.FieldMask;
42 import com.google.protobuf.Timestamp;
43 import com.google.rpc.Status;
44 import io.grpc.StatusRuntimeException;
45 import java.io.IOException;
46 import java.util.ArrayList;
47 import java.util.Arrays;
48 import java.util.HashMap;
49 import java.util.List;
50 import java.util.UUID;
51 import javax.annotation.Generated;
52 import org.junit.After;
53 import org.junit.AfterClass;
54 import org.junit.Assert;
55 import org.junit.Before;
56 import org.junit.BeforeClass;
57 import org.junit.Test;
58 
59 @Generated("by gapic-generator-java")
60 public class DeviceManagerClientTest {
61   private static MockDeviceManager mockDeviceManager;
62   private static MockServiceHelper mockServiceHelper;
63   private LocalChannelProvider channelProvider;
64   private DeviceManagerClient client;
65 
66   @BeforeClass
startStaticServer()67   public static void startStaticServer() {
68     mockDeviceManager = new MockDeviceManager();
69     mockServiceHelper =
70         new MockServiceHelper(
71             UUID.randomUUID().toString(), Arrays.<MockGrpcService>asList(mockDeviceManager));
72     mockServiceHelper.start();
73   }
74 
75   @AfterClass
stopServer()76   public static void stopServer() {
77     mockServiceHelper.stop();
78   }
79 
80   @Before
setUp()81   public void setUp() throws IOException {
82     mockServiceHelper.reset();
83     channelProvider = mockServiceHelper.createChannelProvider();
84     DeviceManagerSettings settings =
85         DeviceManagerSettings.newBuilder()
86             .setTransportChannelProvider(channelProvider)
87             .setCredentialsProvider(NoCredentialsProvider.create())
88             .build();
89     client = DeviceManagerClient.create(settings);
90   }
91 
92   @After
tearDown()93   public void tearDown() throws Exception {
94     client.close();
95   }
96 
97   @Test
createDeviceRegistryTest()98   public void createDeviceRegistryTest() throws Exception {
99     DeviceRegistry expectedResponse =
100         DeviceRegistry.newBuilder()
101             .setId("id3355")
102             .setName(RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]").toString())
103             .addAllEventNotificationConfigs(new ArrayList<EventNotificationConfig>())
104             .setStateNotificationConfig(StateNotificationConfig.newBuilder().build())
105             .setMqttConfig(MqttConfig.newBuilder().build())
106             .setHttpConfig(HttpConfig.newBuilder().build())
107             .setLogLevel(LogLevel.forNumber(0))
108             .addAllCredentials(new ArrayList<RegistryCredential>())
109             .build();
110     mockDeviceManager.addResponse(expectedResponse);
111 
112     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
113     DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
114 
115     DeviceRegistry actualResponse = client.createDeviceRegistry(parent, deviceRegistry);
116     Assert.assertEquals(expectedResponse, actualResponse);
117 
118     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
119     Assert.assertEquals(1, actualRequests.size());
120     CreateDeviceRegistryRequest actualRequest =
121         ((CreateDeviceRegistryRequest) actualRequests.get(0));
122 
123     Assert.assertEquals(parent.toString(), actualRequest.getParent());
124     Assert.assertEquals(deviceRegistry, actualRequest.getDeviceRegistry());
125     Assert.assertTrue(
126         channelProvider.isHeaderSent(
127             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
128             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
129   }
130 
131   @Test
createDeviceRegistryExceptionTest()132   public void createDeviceRegistryExceptionTest() throws Exception {
133     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
134     mockDeviceManager.addException(exception);
135 
136     try {
137       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
138       DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
139       client.createDeviceRegistry(parent, deviceRegistry);
140       Assert.fail("No exception raised");
141     } catch (InvalidArgumentException e) {
142       // Expected exception.
143     }
144   }
145 
146   @Test
createDeviceRegistryTest2()147   public void createDeviceRegistryTest2() throws Exception {
148     DeviceRegistry expectedResponse =
149         DeviceRegistry.newBuilder()
150             .setId("id3355")
151             .setName(RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]").toString())
152             .addAllEventNotificationConfigs(new ArrayList<EventNotificationConfig>())
153             .setStateNotificationConfig(StateNotificationConfig.newBuilder().build())
154             .setMqttConfig(MqttConfig.newBuilder().build())
155             .setHttpConfig(HttpConfig.newBuilder().build())
156             .setLogLevel(LogLevel.forNumber(0))
157             .addAllCredentials(new ArrayList<RegistryCredential>())
158             .build();
159     mockDeviceManager.addResponse(expectedResponse);
160 
161     String parent = "parent-995424086";
162     DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
163 
164     DeviceRegistry actualResponse = client.createDeviceRegistry(parent, deviceRegistry);
165     Assert.assertEquals(expectedResponse, actualResponse);
166 
167     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
168     Assert.assertEquals(1, actualRequests.size());
169     CreateDeviceRegistryRequest actualRequest =
170         ((CreateDeviceRegistryRequest) actualRequests.get(0));
171 
172     Assert.assertEquals(parent, actualRequest.getParent());
173     Assert.assertEquals(deviceRegistry, actualRequest.getDeviceRegistry());
174     Assert.assertTrue(
175         channelProvider.isHeaderSent(
176             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
177             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
178   }
179 
180   @Test
createDeviceRegistryExceptionTest2()181   public void createDeviceRegistryExceptionTest2() throws Exception {
182     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
183     mockDeviceManager.addException(exception);
184 
185     try {
186       String parent = "parent-995424086";
187       DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
188       client.createDeviceRegistry(parent, deviceRegistry);
189       Assert.fail("No exception raised");
190     } catch (InvalidArgumentException e) {
191       // Expected exception.
192     }
193   }
194 
195   @Test
getDeviceRegistryTest()196   public void getDeviceRegistryTest() throws Exception {
197     DeviceRegistry expectedResponse =
198         DeviceRegistry.newBuilder()
199             .setId("id3355")
200             .setName(RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]").toString())
201             .addAllEventNotificationConfigs(new ArrayList<EventNotificationConfig>())
202             .setStateNotificationConfig(StateNotificationConfig.newBuilder().build())
203             .setMqttConfig(MqttConfig.newBuilder().build())
204             .setHttpConfig(HttpConfig.newBuilder().build())
205             .setLogLevel(LogLevel.forNumber(0))
206             .addAllCredentials(new ArrayList<RegistryCredential>())
207             .build();
208     mockDeviceManager.addResponse(expectedResponse);
209 
210     RegistryName name = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
211 
212     DeviceRegistry actualResponse = client.getDeviceRegistry(name);
213     Assert.assertEquals(expectedResponse, actualResponse);
214 
215     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
216     Assert.assertEquals(1, actualRequests.size());
217     GetDeviceRegistryRequest actualRequest = ((GetDeviceRegistryRequest) actualRequests.get(0));
218 
219     Assert.assertEquals(name.toString(), actualRequest.getName());
220     Assert.assertTrue(
221         channelProvider.isHeaderSent(
222             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
223             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
224   }
225 
226   @Test
getDeviceRegistryExceptionTest()227   public void getDeviceRegistryExceptionTest() throws Exception {
228     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
229     mockDeviceManager.addException(exception);
230 
231     try {
232       RegistryName name = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
233       client.getDeviceRegistry(name);
234       Assert.fail("No exception raised");
235     } catch (InvalidArgumentException e) {
236       // Expected exception.
237     }
238   }
239 
240   @Test
getDeviceRegistryTest2()241   public void getDeviceRegistryTest2() throws Exception {
242     DeviceRegistry expectedResponse =
243         DeviceRegistry.newBuilder()
244             .setId("id3355")
245             .setName(RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]").toString())
246             .addAllEventNotificationConfigs(new ArrayList<EventNotificationConfig>())
247             .setStateNotificationConfig(StateNotificationConfig.newBuilder().build())
248             .setMqttConfig(MqttConfig.newBuilder().build())
249             .setHttpConfig(HttpConfig.newBuilder().build())
250             .setLogLevel(LogLevel.forNumber(0))
251             .addAllCredentials(new ArrayList<RegistryCredential>())
252             .build();
253     mockDeviceManager.addResponse(expectedResponse);
254 
255     String name = "name3373707";
256 
257     DeviceRegistry actualResponse = client.getDeviceRegistry(name);
258     Assert.assertEquals(expectedResponse, actualResponse);
259 
260     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
261     Assert.assertEquals(1, actualRequests.size());
262     GetDeviceRegistryRequest actualRequest = ((GetDeviceRegistryRequest) actualRequests.get(0));
263 
264     Assert.assertEquals(name, actualRequest.getName());
265     Assert.assertTrue(
266         channelProvider.isHeaderSent(
267             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
268             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
269   }
270 
271   @Test
getDeviceRegistryExceptionTest2()272   public void getDeviceRegistryExceptionTest2() throws Exception {
273     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
274     mockDeviceManager.addException(exception);
275 
276     try {
277       String name = "name3373707";
278       client.getDeviceRegistry(name);
279       Assert.fail("No exception raised");
280     } catch (InvalidArgumentException e) {
281       // Expected exception.
282     }
283   }
284 
285   @Test
updateDeviceRegistryTest()286   public void updateDeviceRegistryTest() throws Exception {
287     DeviceRegistry expectedResponse =
288         DeviceRegistry.newBuilder()
289             .setId("id3355")
290             .setName(RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]").toString())
291             .addAllEventNotificationConfigs(new ArrayList<EventNotificationConfig>())
292             .setStateNotificationConfig(StateNotificationConfig.newBuilder().build())
293             .setMqttConfig(MqttConfig.newBuilder().build())
294             .setHttpConfig(HttpConfig.newBuilder().build())
295             .setLogLevel(LogLevel.forNumber(0))
296             .addAllCredentials(new ArrayList<RegistryCredential>())
297             .build();
298     mockDeviceManager.addResponse(expectedResponse);
299 
300     DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
301     FieldMask updateMask = FieldMask.newBuilder().build();
302 
303     DeviceRegistry actualResponse = client.updateDeviceRegistry(deviceRegistry, updateMask);
304     Assert.assertEquals(expectedResponse, actualResponse);
305 
306     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
307     Assert.assertEquals(1, actualRequests.size());
308     UpdateDeviceRegistryRequest actualRequest =
309         ((UpdateDeviceRegistryRequest) actualRequests.get(0));
310 
311     Assert.assertEquals(deviceRegistry, actualRequest.getDeviceRegistry());
312     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
313     Assert.assertTrue(
314         channelProvider.isHeaderSent(
315             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
316             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
317   }
318 
319   @Test
updateDeviceRegistryExceptionTest()320   public void updateDeviceRegistryExceptionTest() throws Exception {
321     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
322     mockDeviceManager.addException(exception);
323 
324     try {
325       DeviceRegistry deviceRegistry = DeviceRegistry.newBuilder().build();
326       FieldMask updateMask = FieldMask.newBuilder().build();
327       client.updateDeviceRegistry(deviceRegistry, updateMask);
328       Assert.fail("No exception raised");
329     } catch (InvalidArgumentException e) {
330       // Expected exception.
331     }
332   }
333 
334   @Test
deleteDeviceRegistryTest()335   public void deleteDeviceRegistryTest() throws Exception {
336     Empty expectedResponse = Empty.newBuilder().build();
337     mockDeviceManager.addResponse(expectedResponse);
338 
339     RegistryName name = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
340 
341     client.deleteDeviceRegistry(name);
342 
343     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
344     Assert.assertEquals(1, actualRequests.size());
345     DeleteDeviceRegistryRequest actualRequest =
346         ((DeleteDeviceRegistryRequest) actualRequests.get(0));
347 
348     Assert.assertEquals(name.toString(), actualRequest.getName());
349     Assert.assertTrue(
350         channelProvider.isHeaderSent(
351             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
352             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
353   }
354 
355   @Test
deleteDeviceRegistryExceptionTest()356   public void deleteDeviceRegistryExceptionTest() throws Exception {
357     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
358     mockDeviceManager.addException(exception);
359 
360     try {
361       RegistryName name = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
362       client.deleteDeviceRegistry(name);
363       Assert.fail("No exception raised");
364     } catch (InvalidArgumentException e) {
365       // Expected exception.
366     }
367   }
368 
369   @Test
deleteDeviceRegistryTest2()370   public void deleteDeviceRegistryTest2() throws Exception {
371     Empty expectedResponse = Empty.newBuilder().build();
372     mockDeviceManager.addResponse(expectedResponse);
373 
374     String name = "name3373707";
375 
376     client.deleteDeviceRegistry(name);
377 
378     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
379     Assert.assertEquals(1, actualRequests.size());
380     DeleteDeviceRegistryRequest actualRequest =
381         ((DeleteDeviceRegistryRequest) actualRequests.get(0));
382 
383     Assert.assertEquals(name, actualRequest.getName());
384     Assert.assertTrue(
385         channelProvider.isHeaderSent(
386             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
387             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
388   }
389 
390   @Test
deleteDeviceRegistryExceptionTest2()391   public void deleteDeviceRegistryExceptionTest2() throws Exception {
392     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
393     mockDeviceManager.addException(exception);
394 
395     try {
396       String name = "name3373707";
397       client.deleteDeviceRegistry(name);
398       Assert.fail("No exception raised");
399     } catch (InvalidArgumentException e) {
400       // Expected exception.
401     }
402   }
403 
404   @Test
listDeviceRegistriesTest()405   public void listDeviceRegistriesTest() throws Exception {
406     DeviceRegistry responsesElement = DeviceRegistry.newBuilder().build();
407     ListDeviceRegistriesResponse expectedResponse =
408         ListDeviceRegistriesResponse.newBuilder()
409             .setNextPageToken("")
410             .addAllDeviceRegistries(Arrays.asList(responsesElement))
411             .build();
412     mockDeviceManager.addResponse(expectedResponse);
413 
414     LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
415 
416     ListDeviceRegistriesPagedResponse pagedListResponse = client.listDeviceRegistries(parent);
417 
418     List<DeviceRegistry> resources = Lists.newArrayList(pagedListResponse.iterateAll());
419 
420     Assert.assertEquals(1, resources.size());
421     Assert.assertEquals(expectedResponse.getDeviceRegistriesList().get(0), resources.get(0));
422 
423     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
424     Assert.assertEquals(1, actualRequests.size());
425     ListDeviceRegistriesRequest actualRequest =
426         ((ListDeviceRegistriesRequest) actualRequests.get(0));
427 
428     Assert.assertEquals(parent.toString(), actualRequest.getParent());
429     Assert.assertTrue(
430         channelProvider.isHeaderSent(
431             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
432             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
433   }
434 
435   @Test
listDeviceRegistriesExceptionTest()436   public void listDeviceRegistriesExceptionTest() throws Exception {
437     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
438     mockDeviceManager.addException(exception);
439 
440     try {
441       LocationName parent = LocationName.of("[PROJECT]", "[LOCATION]");
442       client.listDeviceRegistries(parent);
443       Assert.fail("No exception raised");
444     } catch (InvalidArgumentException e) {
445       // Expected exception.
446     }
447   }
448 
449   @Test
listDeviceRegistriesTest2()450   public void listDeviceRegistriesTest2() throws Exception {
451     DeviceRegistry responsesElement = DeviceRegistry.newBuilder().build();
452     ListDeviceRegistriesResponse expectedResponse =
453         ListDeviceRegistriesResponse.newBuilder()
454             .setNextPageToken("")
455             .addAllDeviceRegistries(Arrays.asList(responsesElement))
456             .build();
457     mockDeviceManager.addResponse(expectedResponse);
458 
459     String parent = "parent-995424086";
460 
461     ListDeviceRegistriesPagedResponse pagedListResponse = client.listDeviceRegistries(parent);
462 
463     List<DeviceRegistry> resources = Lists.newArrayList(pagedListResponse.iterateAll());
464 
465     Assert.assertEquals(1, resources.size());
466     Assert.assertEquals(expectedResponse.getDeviceRegistriesList().get(0), resources.get(0));
467 
468     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
469     Assert.assertEquals(1, actualRequests.size());
470     ListDeviceRegistriesRequest actualRequest =
471         ((ListDeviceRegistriesRequest) actualRequests.get(0));
472 
473     Assert.assertEquals(parent, actualRequest.getParent());
474     Assert.assertTrue(
475         channelProvider.isHeaderSent(
476             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
477             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
478   }
479 
480   @Test
listDeviceRegistriesExceptionTest2()481   public void listDeviceRegistriesExceptionTest2() throws Exception {
482     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
483     mockDeviceManager.addException(exception);
484 
485     try {
486       String parent = "parent-995424086";
487       client.listDeviceRegistries(parent);
488       Assert.fail("No exception raised");
489     } catch (InvalidArgumentException e) {
490       // Expected exception.
491     }
492   }
493 
494   @Test
createDeviceTest()495   public void createDeviceTest() throws Exception {
496     Device expectedResponse =
497         Device.newBuilder()
498             .setId("id3355")
499             .setName(DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]").toString())
500             .setNumId(-1034366860)
501             .addAllCredentials(new ArrayList<DeviceCredential>())
502             .setLastHeartbeatTime(Timestamp.newBuilder().build())
503             .setLastEventTime(Timestamp.newBuilder().build())
504             .setLastStateTime(Timestamp.newBuilder().build())
505             .setLastConfigAckTime(Timestamp.newBuilder().build())
506             .setLastConfigSendTime(Timestamp.newBuilder().build())
507             .setBlocked(true)
508             .setLastErrorTime(Timestamp.newBuilder().build())
509             .setLastErrorStatus(Status.newBuilder().build())
510             .setConfig(DeviceConfig.newBuilder().build())
511             .setState(DeviceState.newBuilder().build())
512             .setLogLevel(LogLevel.forNumber(0))
513             .putAllMetadata(new HashMap<String, String>())
514             .setGatewayConfig(GatewayConfig.newBuilder().build())
515             .build();
516     mockDeviceManager.addResponse(expectedResponse);
517 
518     RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
519     Device device = Device.newBuilder().build();
520 
521     Device actualResponse = client.createDevice(parent, device);
522     Assert.assertEquals(expectedResponse, actualResponse);
523 
524     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
525     Assert.assertEquals(1, actualRequests.size());
526     CreateDeviceRequest actualRequest = ((CreateDeviceRequest) actualRequests.get(0));
527 
528     Assert.assertEquals(parent.toString(), actualRequest.getParent());
529     Assert.assertEquals(device, actualRequest.getDevice());
530     Assert.assertTrue(
531         channelProvider.isHeaderSent(
532             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
533             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
534   }
535 
536   @Test
createDeviceExceptionTest()537   public void createDeviceExceptionTest() throws Exception {
538     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
539     mockDeviceManager.addException(exception);
540 
541     try {
542       RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
543       Device device = Device.newBuilder().build();
544       client.createDevice(parent, device);
545       Assert.fail("No exception raised");
546     } catch (InvalidArgumentException e) {
547       // Expected exception.
548     }
549   }
550 
551   @Test
createDeviceTest2()552   public void createDeviceTest2() throws Exception {
553     Device expectedResponse =
554         Device.newBuilder()
555             .setId("id3355")
556             .setName(DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]").toString())
557             .setNumId(-1034366860)
558             .addAllCredentials(new ArrayList<DeviceCredential>())
559             .setLastHeartbeatTime(Timestamp.newBuilder().build())
560             .setLastEventTime(Timestamp.newBuilder().build())
561             .setLastStateTime(Timestamp.newBuilder().build())
562             .setLastConfigAckTime(Timestamp.newBuilder().build())
563             .setLastConfigSendTime(Timestamp.newBuilder().build())
564             .setBlocked(true)
565             .setLastErrorTime(Timestamp.newBuilder().build())
566             .setLastErrorStatus(Status.newBuilder().build())
567             .setConfig(DeviceConfig.newBuilder().build())
568             .setState(DeviceState.newBuilder().build())
569             .setLogLevel(LogLevel.forNumber(0))
570             .putAllMetadata(new HashMap<String, String>())
571             .setGatewayConfig(GatewayConfig.newBuilder().build())
572             .build();
573     mockDeviceManager.addResponse(expectedResponse);
574 
575     String parent = "parent-995424086";
576     Device device = Device.newBuilder().build();
577 
578     Device actualResponse = client.createDevice(parent, device);
579     Assert.assertEquals(expectedResponse, actualResponse);
580 
581     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
582     Assert.assertEquals(1, actualRequests.size());
583     CreateDeviceRequest actualRequest = ((CreateDeviceRequest) actualRequests.get(0));
584 
585     Assert.assertEquals(parent, actualRequest.getParent());
586     Assert.assertEquals(device, actualRequest.getDevice());
587     Assert.assertTrue(
588         channelProvider.isHeaderSent(
589             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
590             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
591   }
592 
593   @Test
createDeviceExceptionTest2()594   public void createDeviceExceptionTest2() throws Exception {
595     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
596     mockDeviceManager.addException(exception);
597 
598     try {
599       String parent = "parent-995424086";
600       Device device = Device.newBuilder().build();
601       client.createDevice(parent, device);
602       Assert.fail("No exception raised");
603     } catch (InvalidArgumentException e) {
604       // Expected exception.
605     }
606   }
607 
608   @Test
getDeviceTest()609   public void getDeviceTest() throws Exception {
610     Device expectedResponse =
611         Device.newBuilder()
612             .setId("id3355")
613             .setName(DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]").toString())
614             .setNumId(-1034366860)
615             .addAllCredentials(new ArrayList<DeviceCredential>())
616             .setLastHeartbeatTime(Timestamp.newBuilder().build())
617             .setLastEventTime(Timestamp.newBuilder().build())
618             .setLastStateTime(Timestamp.newBuilder().build())
619             .setLastConfigAckTime(Timestamp.newBuilder().build())
620             .setLastConfigSendTime(Timestamp.newBuilder().build())
621             .setBlocked(true)
622             .setLastErrorTime(Timestamp.newBuilder().build())
623             .setLastErrorStatus(Status.newBuilder().build())
624             .setConfig(DeviceConfig.newBuilder().build())
625             .setState(DeviceState.newBuilder().build())
626             .setLogLevel(LogLevel.forNumber(0))
627             .putAllMetadata(new HashMap<String, String>())
628             .setGatewayConfig(GatewayConfig.newBuilder().build())
629             .build();
630     mockDeviceManager.addResponse(expectedResponse);
631 
632     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
633 
634     Device actualResponse = client.getDevice(name);
635     Assert.assertEquals(expectedResponse, actualResponse);
636 
637     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
638     Assert.assertEquals(1, actualRequests.size());
639     GetDeviceRequest actualRequest = ((GetDeviceRequest) actualRequests.get(0));
640 
641     Assert.assertEquals(name.toString(), actualRequest.getName());
642     Assert.assertTrue(
643         channelProvider.isHeaderSent(
644             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
645             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
646   }
647 
648   @Test
getDeviceExceptionTest()649   public void getDeviceExceptionTest() throws Exception {
650     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
651     mockDeviceManager.addException(exception);
652 
653     try {
654       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
655       client.getDevice(name);
656       Assert.fail("No exception raised");
657     } catch (InvalidArgumentException e) {
658       // Expected exception.
659     }
660   }
661 
662   @Test
getDeviceTest2()663   public void getDeviceTest2() throws Exception {
664     Device expectedResponse =
665         Device.newBuilder()
666             .setId("id3355")
667             .setName(DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]").toString())
668             .setNumId(-1034366860)
669             .addAllCredentials(new ArrayList<DeviceCredential>())
670             .setLastHeartbeatTime(Timestamp.newBuilder().build())
671             .setLastEventTime(Timestamp.newBuilder().build())
672             .setLastStateTime(Timestamp.newBuilder().build())
673             .setLastConfigAckTime(Timestamp.newBuilder().build())
674             .setLastConfigSendTime(Timestamp.newBuilder().build())
675             .setBlocked(true)
676             .setLastErrorTime(Timestamp.newBuilder().build())
677             .setLastErrorStatus(Status.newBuilder().build())
678             .setConfig(DeviceConfig.newBuilder().build())
679             .setState(DeviceState.newBuilder().build())
680             .setLogLevel(LogLevel.forNumber(0))
681             .putAllMetadata(new HashMap<String, String>())
682             .setGatewayConfig(GatewayConfig.newBuilder().build())
683             .build();
684     mockDeviceManager.addResponse(expectedResponse);
685 
686     String name = "name3373707";
687 
688     Device actualResponse = client.getDevice(name);
689     Assert.assertEquals(expectedResponse, actualResponse);
690 
691     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
692     Assert.assertEquals(1, actualRequests.size());
693     GetDeviceRequest actualRequest = ((GetDeviceRequest) actualRequests.get(0));
694 
695     Assert.assertEquals(name, actualRequest.getName());
696     Assert.assertTrue(
697         channelProvider.isHeaderSent(
698             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
699             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
700   }
701 
702   @Test
getDeviceExceptionTest2()703   public void getDeviceExceptionTest2() throws Exception {
704     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
705     mockDeviceManager.addException(exception);
706 
707     try {
708       String name = "name3373707";
709       client.getDevice(name);
710       Assert.fail("No exception raised");
711     } catch (InvalidArgumentException e) {
712       // Expected exception.
713     }
714   }
715 
716   @Test
updateDeviceTest()717   public void updateDeviceTest() throws Exception {
718     Device expectedResponse =
719         Device.newBuilder()
720             .setId("id3355")
721             .setName(DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]").toString())
722             .setNumId(-1034366860)
723             .addAllCredentials(new ArrayList<DeviceCredential>())
724             .setLastHeartbeatTime(Timestamp.newBuilder().build())
725             .setLastEventTime(Timestamp.newBuilder().build())
726             .setLastStateTime(Timestamp.newBuilder().build())
727             .setLastConfigAckTime(Timestamp.newBuilder().build())
728             .setLastConfigSendTime(Timestamp.newBuilder().build())
729             .setBlocked(true)
730             .setLastErrorTime(Timestamp.newBuilder().build())
731             .setLastErrorStatus(Status.newBuilder().build())
732             .setConfig(DeviceConfig.newBuilder().build())
733             .setState(DeviceState.newBuilder().build())
734             .setLogLevel(LogLevel.forNumber(0))
735             .putAllMetadata(new HashMap<String, String>())
736             .setGatewayConfig(GatewayConfig.newBuilder().build())
737             .build();
738     mockDeviceManager.addResponse(expectedResponse);
739 
740     Device device = Device.newBuilder().build();
741     FieldMask updateMask = FieldMask.newBuilder().build();
742 
743     Device actualResponse = client.updateDevice(device, updateMask);
744     Assert.assertEquals(expectedResponse, actualResponse);
745 
746     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
747     Assert.assertEquals(1, actualRequests.size());
748     UpdateDeviceRequest actualRequest = ((UpdateDeviceRequest) actualRequests.get(0));
749 
750     Assert.assertEquals(device, actualRequest.getDevice());
751     Assert.assertEquals(updateMask, actualRequest.getUpdateMask());
752     Assert.assertTrue(
753         channelProvider.isHeaderSent(
754             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
755             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
756   }
757 
758   @Test
updateDeviceExceptionTest()759   public void updateDeviceExceptionTest() throws Exception {
760     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
761     mockDeviceManager.addException(exception);
762 
763     try {
764       Device device = Device.newBuilder().build();
765       FieldMask updateMask = FieldMask.newBuilder().build();
766       client.updateDevice(device, updateMask);
767       Assert.fail("No exception raised");
768     } catch (InvalidArgumentException e) {
769       // Expected exception.
770     }
771   }
772 
773   @Test
deleteDeviceTest()774   public void deleteDeviceTest() throws Exception {
775     Empty expectedResponse = Empty.newBuilder().build();
776     mockDeviceManager.addResponse(expectedResponse);
777 
778     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
779 
780     client.deleteDevice(name);
781 
782     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
783     Assert.assertEquals(1, actualRequests.size());
784     DeleteDeviceRequest actualRequest = ((DeleteDeviceRequest) actualRequests.get(0));
785 
786     Assert.assertEquals(name.toString(), actualRequest.getName());
787     Assert.assertTrue(
788         channelProvider.isHeaderSent(
789             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
790             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
791   }
792 
793   @Test
deleteDeviceExceptionTest()794   public void deleteDeviceExceptionTest() throws Exception {
795     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
796     mockDeviceManager.addException(exception);
797 
798     try {
799       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
800       client.deleteDevice(name);
801       Assert.fail("No exception raised");
802     } catch (InvalidArgumentException e) {
803       // Expected exception.
804     }
805   }
806 
807   @Test
deleteDeviceTest2()808   public void deleteDeviceTest2() throws Exception {
809     Empty expectedResponse = Empty.newBuilder().build();
810     mockDeviceManager.addResponse(expectedResponse);
811 
812     String name = "name3373707";
813 
814     client.deleteDevice(name);
815 
816     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
817     Assert.assertEquals(1, actualRequests.size());
818     DeleteDeviceRequest actualRequest = ((DeleteDeviceRequest) actualRequests.get(0));
819 
820     Assert.assertEquals(name, actualRequest.getName());
821     Assert.assertTrue(
822         channelProvider.isHeaderSent(
823             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
824             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
825   }
826 
827   @Test
deleteDeviceExceptionTest2()828   public void deleteDeviceExceptionTest2() throws Exception {
829     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
830     mockDeviceManager.addException(exception);
831 
832     try {
833       String name = "name3373707";
834       client.deleteDevice(name);
835       Assert.fail("No exception raised");
836     } catch (InvalidArgumentException e) {
837       // Expected exception.
838     }
839   }
840 
841   @Test
listDevicesTest()842   public void listDevicesTest() throws Exception {
843     Device responsesElement = Device.newBuilder().build();
844     ListDevicesResponse expectedResponse =
845         ListDevicesResponse.newBuilder()
846             .setNextPageToken("")
847             .addAllDevices(Arrays.asList(responsesElement))
848             .build();
849     mockDeviceManager.addResponse(expectedResponse);
850 
851     RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
852 
853     ListDevicesPagedResponse pagedListResponse = client.listDevices(parent);
854 
855     List<Device> resources = Lists.newArrayList(pagedListResponse.iterateAll());
856 
857     Assert.assertEquals(1, resources.size());
858     Assert.assertEquals(expectedResponse.getDevicesList().get(0), resources.get(0));
859 
860     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
861     Assert.assertEquals(1, actualRequests.size());
862     ListDevicesRequest actualRequest = ((ListDevicesRequest) actualRequests.get(0));
863 
864     Assert.assertEquals(parent.toString(), actualRequest.getParent());
865     Assert.assertTrue(
866         channelProvider.isHeaderSent(
867             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
868             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
869   }
870 
871   @Test
listDevicesExceptionTest()872   public void listDevicesExceptionTest() throws Exception {
873     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
874     mockDeviceManager.addException(exception);
875 
876     try {
877       RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
878       client.listDevices(parent);
879       Assert.fail("No exception raised");
880     } catch (InvalidArgumentException e) {
881       // Expected exception.
882     }
883   }
884 
885   @Test
listDevicesTest2()886   public void listDevicesTest2() throws Exception {
887     Device responsesElement = Device.newBuilder().build();
888     ListDevicesResponse expectedResponse =
889         ListDevicesResponse.newBuilder()
890             .setNextPageToken("")
891             .addAllDevices(Arrays.asList(responsesElement))
892             .build();
893     mockDeviceManager.addResponse(expectedResponse);
894 
895     String parent = "parent-995424086";
896 
897     ListDevicesPagedResponse pagedListResponse = client.listDevices(parent);
898 
899     List<Device> resources = Lists.newArrayList(pagedListResponse.iterateAll());
900 
901     Assert.assertEquals(1, resources.size());
902     Assert.assertEquals(expectedResponse.getDevicesList().get(0), resources.get(0));
903 
904     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
905     Assert.assertEquals(1, actualRequests.size());
906     ListDevicesRequest actualRequest = ((ListDevicesRequest) actualRequests.get(0));
907 
908     Assert.assertEquals(parent, actualRequest.getParent());
909     Assert.assertTrue(
910         channelProvider.isHeaderSent(
911             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
912             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
913   }
914 
915   @Test
listDevicesExceptionTest2()916   public void listDevicesExceptionTest2() throws Exception {
917     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
918     mockDeviceManager.addException(exception);
919 
920     try {
921       String parent = "parent-995424086";
922       client.listDevices(parent);
923       Assert.fail("No exception raised");
924     } catch (InvalidArgumentException e) {
925       // Expected exception.
926     }
927   }
928 
929   @Test
modifyCloudToDeviceConfigTest()930   public void modifyCloudToDeviceConfigTest() throws Exception {
931     DeviceConfig expectedResponse =
932         DeviceConfig.newBuilder()
933             .setVersion(351608024)
934             .setCloudUpdateTime(Timestamp.newBuilder().build())
935             .setDeviceAckTime(Timestamp.newBuilder().build())
936             .setBinaryData(ByteString.EMPTY)
937             .build();
938     mockDeviceManager.addResponse(expectedResponse);
939 
940     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
941     ByteString binaryData = ByteString.EMPTY;
942 
943     DeviceConfig actualResponse = client.modifyCloudToDeviceConfig(name, binaryData);
944     Assert.assertEquals(expectedResponse, actualResponse);
945 
946     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
947     Assert.assertEquals(1, actualRequests.size());
948     ModifyCloudToDeviceConfigRequest actualRequest =
949         ((ModifyCloudToDeviceConfigRequest) actualRequests.get(0));
950 
951     Assert.assertEquals(name.toString(), actualRequest.getName());
952     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
953     Assert.assertTrue(
954         channelProvider.isHeaderSent(
955             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
956             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
957   }
958 
959   @Test
modifyCloudToDeviceConfigExceptionTest()960   public void modifyCloudToDeviceConfigExceptionTest() throws Exception {
961     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
962     mockDeviceManager.addException(exception);
963 
964     try {
965       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
966       ByteString binaryData = ByteString.EMPTY;
967       client.modifyCloudToDeviceConfig(name, binaryData);
968       Assert.fail("No exception raised");
969     } catch (InvalidArgumentException e) {
970       // Expected exception.
971     }
972   }
973 
974   @Test
modifyCloudToDeviceConfigTest2()975   public void modifyCloudToDeviceConfigTest2() throws Exception {
976     DeviceConfig expectedResponse =
977         DeviceConfig.newBuilder()
978             .setVersion(351608024)
979             .setCloudUpdateTime(Timestamp.newBuilder().build())
980             .setDeviceAckTime(Timestamp.newBuilder().build())
981             .setBinaryData(ByteString.EMPTY)
982             .build();
983     mockDeviceManager.addResponse(expectedResponse);
984 
985     String name = "name3373707";
986     ByteString binaryData = ByteString.EMPTY;
987 
988     DeviceConfig actualResponse = client.modifyCloudToDeviceConfig(name, binaryData);
989     Assert.assertEquals(expectedResponse, actualResponse);
990 
991     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
992     Assert.assertEquals(1, actualRequests.size());
993     ModifyCloudToDeviceConfigRequest actualRequest =
994         ((ModifyCloudToDeviceConfigRequest) actualRequests.get(0));
995 
996     Assert.assertEquals(name, actualRequest.getName());
997     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
998     Assert.assertTrue(
999         channelProvider.isHeaderSent(
1000             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1001             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1002   }
1003 
1004   @Test
modifyCloudToDeviceConfigExceptionTest2()1005   public void modifyCloudToDeviceConfigExceptionTest2() throws Exception {
1006     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1007     mockDeviceManager.addException(exception);
1008 
1009     try {
1010       String name = "name3373707";
1011       ByteString binaryData = ByteString.EMPTY;
1012       client.modifyCloudToDeviceConfig(name, binaryData);
1013       Assert.fail("No exception raised");
1014     } catch (InvalidArgumentException e) {
1015       // Expected exception.
1016     }
1017   }
1018 
1019   @Test
listDeviceConfigVersionsTest()1020   public void listDeviceConfigVersionsTest() throws Exception {
1021     ListDeviceConfigVersionsResponse expectedResponse =
1022         ListDeviceConfigVersionsResponse.newBuilder()
1023             .addAllDeviceConfigs(new ArrayList<DeviceConfig>())
1024             .build();
1025     mockDeviceManager.addResponse(expectedResponse);
1026 
1027     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1028 
1029     ListDeviceConfigVersionsResponse actualResponse = client.listDeviceConfigVersions(name);
1030     Assert.assertEquals(expectedResponse, actualResponse);
1031 
1032     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1033     Assert.assertEquals(1, actualRequests.size());
1034     ListDeviceConfigVersionsRequest actualRequest =
1035         ((ListDeviceConfigVersionsRequest) actualRequests.get(0));
1036 
1037     Assert.assertEquals(name.toString(), actualRequest.getName());
1038     Assert.assertTrue(
1039         channelProvider.isHeaderSent(
1040             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1041             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1042   }
1043 
1044   @Test
listDeviceConfigVersionsExceptionTest()1045   public void listDeviceConfigVersionsExceptionTest() throws Exception {
1046     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1047     mockDeviceManager.addException(exception);
1048 
1049     try {
1050       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1051       client.listDeviceConfigVersions(name);
1052       Assert.fail("No exception raised");
1053     } catch (InvalidArgumentException e) {
1054       // Expected exception.
1055     }
1056   }
1057 
1058   @Test
listDeviceConfigVersionsTest2()1059   public void listDeviceConfigVersionsTest2() throws Exception {
1060     ListDeviceConfigVersionsResponse expectedResponse =
1061         ListDeviceConfigVersionsResponse.newBuilder()
1062             .addAllDeviceConfigs(new ArrayList<DeviceConfig>())
1063             .build();
1064     mockDeviceManager.addResponse(expectedResponse);
1065 
1066     String name = "name3373707";
1067 
1068     ListDeviceConfigVersionsResponse actualResponse = client.listDeviceConfigVersions(name);
1069     Assert.assertEquals(expectedResponse, actualResponse);
1070 
1071     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1072     Assert.assertEquals(1, actualRequests.size());
1073     ListDeviceConfigVersionsRequest actualRequest =
1074         ((ListDeviceConfigVersionsRequest) actualRequests.get(0));
1075 
1076     Assert.assertEquals(name, actualRequest.getName());
1077     Assert.assertTrue(
1078         channelProvider.isHeaderSent(
1079             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1080             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1081   }
1082 
1083   @Test
listDeviceConfigVersionsExceptionTest2()1084   public void listDeviceConfigVersionsExceptionTest2() throws Exception {
1085     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1086     mockDeviceManager.addException(exception);
1087 
1088     try {
1089       String name = "name3373707";
1090       client.listDeviceConfigVersions(name);
1091       Assert.fail("No exception raised");
1092     } catch (InvalidArgumentException e) {
1093       // Expected exception.
1094     }
1095   }
1096 
1097   @Test
listDeviceStatesTest()1098   public void listDeviceStatesTest() throws Exception {
1099     ListDeviceStatesResponse expectedResponse =
1100         ListDeviceStatesResponse.newBuilder()
1101             .addAllDeviceStates(new ArrayList<DeviceState>())
1102             .build();
1103     mockDeviceManager.addResponse(expectedResponse);
1104 
1105     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1106 
1107     ListDeviceStatesResponse actualResponse = client.listDeviceStates(name);
1108     Assert.assertEquals(expectedResponse, actualResponse);
1109 
1110     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1111     Assert.assertEquals(1, actualRequests.size());
1112     ListDeviceStatesRequest actualRequest = ((ListDeviceStatesRequest) actualRequests.get(0));
1113 
1114     Assert.assertEquals(name.toString(), actualRequest.getName());
1115     Assert.assertTrue(
1116         channelProvider.isHeaderSent(
1117             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1118             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1119   }
1120 
1121   @Test
listDeviceStatesExceptionTest()1122   public void listDeviceStatesExceptionTest() throws Exception {
1123     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1124     mockDeviceManager.addException(exception);
1125 
1126     try {
1127       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1128       client.listDeviceStates(name);
1129       Assert.fail("No exception raised");
1130     } catch (InvalidArgumentException e) {
1131       // Expected exception.
1132     }
1133   }
1134 
1135   @Test
listDeviceStatesTest2()1136   public void listDeviceStatesTest2() throws Exception {
1137     ListDeviceStatesResponse expectedResponse =
1138         ListDeviceStatesResponse.newBuilder()
1139             .addAllDeviceStates(new ArrayList<DeviceState>())
1140             .build();
1141     mockDeviceManager.addResponse(expectedResponse);
1142 
1143     String name = "name3373707";
1144 
1145     ListDeviceStatesResponse actualResponse = client.listDeviceStates(name);
1146     Assert.assertEquals(expectedResponse, actualResponse);
1147 
1148     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1149     Assert.assertEquals(1, actualRequests.size());
1150     ListDeviceStatesRequest actualRequest = ((ListDeviceStatesRequest) actualRequests.get(0));
1151 
1152     Assert.assertEquals(name, actualRequest.getName());
1153     Assert.assertTrue(
1154         channelProvider.isHeaderSent(
1155             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1156             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1157   }
1158 
1159   @Test
listDeviceStatesExceptionTest2()1160   public void listDeviceStatesExceptionTest2() throws Exception {
1161     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1162     mockDeviceManager.addException(exception);
1163 
1164     try {
1165       String name = "name3373707";
1166       client.listDeviceStates(name);
1167       Assert.fail("No exception raised");
1168     } catch (InvalidArgumentException e) {
1169       // Expected exception.
1170     }
1171   }
1172 
1173   @Test
setIamPolicyTest()1174   public void setIamPolicyTest() throws Exception {
1175     Policy expectedResponse =
1176         Policy.newBuilder()
1177             .setVersion(351608024)
1178             .addAllBindings(new ArrayList<Binding>())
1179             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1180             .setEtag(ByteString.EMPTY)
1181             .build();
1182     mockDeviceManager.addResponse(expectedResponse);
1183 
1184     ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1185     Policy policy = Policy.newBuilder().build();
1186 
1187     Policy actualResponse = client.setIamPolicy(resource, policy);
1188     Assert.assertEquals(expectedResponse, actualResponse);
1189 
1190     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1191     Assert.assertEquals(1, actualRequests.size());
1192     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1193 
1194     Assert.assertEquals(resource.toString(), actualRequest.getResource());
1195     Assert.assertEquals(policy, actualRequest.getPolicy());
1196     Assert.assertTrue(
1197         channelProvider.isHeaderSent(
1198             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1199             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1200   }
1201 
1202   @Test
setIamPolicyExceptionTest()1203   public void setIamPolicyExceptionTest() throws Exception {
1204     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1205     mockDeviceManager.addException(exception);
1206 
1207     try {
1208       ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1209       Policy policy = Policy.newBuilder().build();
1210       client.setIamPolicy(resource, policy);
1211       Assert.fail("No exception raised");
1212     } catch (InvalidArgumentException e) {
1213       // Expected exception.
1214     }
1215   }
1216 
1217   @Test
setIamPolicyTest2()1218   public void setIamPolicyTest2() throws Exception {
1219     Policy expectedResponse =
1220         Policy.newBuilder()
1221             .setVersion(351608024)
1222             .addAllBindings(new ArrayList<Binding>())
1223             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1224             .setEtag(ByteString.EMPTY)
1225             .build();
1226     mockDeviceManager.addResponse(expectedResponse);
1227 
1228     String resource = "resource-341064690";
1229     Policy policy = Policy.newBuilder().build();
1230 
1231     Policy actualResponse = client.setIamPolicy(resource, policy);
1232     Assert.assertEquals(expectedResponse, actualResponse);
1233 
1234     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1235     Assert.assertEquals(1, actualRequests.size());
1236     SetIamPolicyRequest actualRequest = ((SetIamPolicyRequest) actualRequests.get(0));
1237 
1238     Assert.assertEquals(resource, actualRequest.getResource());
1239     Assert.assertEquals(policy, actualRequest.getPolicy());
1240     Assert.assertTrue(
1241         channelProvider.isHeaderSent(
1242             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1243             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1244   }
1245 
1246   @Test
setIamPolicyExceptionTest2()1247   public void setIamPolicyExceptionTest2() throws Exception {
1248     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1249     mockDeviceManager.addException(exception);
1250 
1251     try {
1252       String resource = "resource-341064690";
1253       Policy policy = Policy.newBuilder().build();
1254       client.setIamPolicy(resource, policy);
1255       Assert.fail("No exception raised");
1256     } catch (InvalidArgumentException e) {
1257       // Expected exception.
1258     }
1259   }
1260 
1261   @Test
getIamPolicyTest()1262   public void getIamPolicyTest() throws Exception {
1263     Policy expectedResponse =
1264         Policy.newBuilder()
1265             .setVersion(351608024)
1266             .addAllBindings(new ArrayList<Binding>())
1267             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1268             .setEtag(ByteString.EMPTY)
1269             .build();
1270     mockDeviceManager.addResponse(expectedResponse);
1271 
1272     ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1273 
1274     Policy actualResponse = client.getIamPolicy(resource);
1275     Assert.assertEquals(expectedResponse, actualResponse);
1276 
1277     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1278     Assert.assertEquals(1, actualRequests.size());
1279     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1280 
1281     Assert.assertEquals(resource.toString(), actualRequest.getResource());
1282     Assert.assertTrue(
1283         channelProvider.isHeaderSent(
1284             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1285             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1286   }
1287 
1288   @Test
getIamPolicyExceptionTest()1289   public void getIamPolicyExceptionTest() throws Exception {
1290     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1291     mockDeviceManager.addException(exception);
1292 
1293     try {
1294       ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1295       client.getIamPolicy(resource);
1296       Assert.fail("No exception raised");
1297     } catch (InvalidArgumentException e) {
1298       // Expected exception.
1299     }
1300   }
1301 
1302   @Test
getIamPolicyTest2()1303   public void getIamPolicyTest2() throws Exception {
1304     Policy expectedResponse =
1305         Policy.newBuilder()
1306             .setVersion(351608024)
1307             .addAllBindings(new ArrayList<Binding>())
1308             .addAllAuditConfigs(new ArrayList<AuditConfig>())
1309             .setEtag(ByteString.EMPTY)
1310             .build();
1311     mockDeviceManager.addResponse(expectedResponse);
1312 
1313     String resource = "resource-341064690";
1314 
1315     Policy actualResponse = client.getIamPolicy(resource);
1316     Assert.assertEquals(expectedResponse, actualResponse);
1317 
1318     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1319     Assert.assertEquals(1, actualRequests.size());
1320     GetIamPolicyRequest actualRequest = ((GetIamPolicyRequest) actualRequests.get(0));
1321 
1322     Assert.assertEquals(resource, actualRequest.getResource());
1323     Assert.assertTrue(
1324         channelProvider.isHeaderSent(
1325             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1326             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1327   }
1328 
1329   @Test
getIamPolicyExceptionTest2()1330   public void getIamPolicyExceptionTest2() throws Exception {
1331     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1332     mockDeviceManager.addException(exception);
1333 
1334     try {
1335       String resource = "resource-341064690";
1336       client.getIamPolicy(resource);
1337       Assert.fail("No exception raised");
1338     } catch (InvalidArgumentException e) {
1339       // Expected exception.
1340     }
1341   }
1342 
1343   @Test
testIamPermissionsTest()1344   public void testIamPermissionsTest() throws Exception {
1345     TestIamPermissionsResponse expectedResponse =
1346         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1347     mockDeviceManager.addResponse(expectedResponse);
1348 
1349     ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1350     List<String> permissions = new ArrayList<>();
1351 
1352     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
1353     Assert.assertEquals(expectedResponse, actualResponse);
1354 
1355     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1356     Assert.assertEquals(1, actualRequests.size());
1357     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1358 
1359     Assert.assertEquals(resource.toString(), actualRequest.getResource());
1360     Assert.assertEquals(permissions, actualRequest.getPermissionsList());
1361     Assert.assertTrue(
1362         channelProvider.isHeaderSent(
1363             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1364             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1365   }
1366 
1367   @Test
testIamPermissionsExceptionTest()1368   public void testIamPermissionsExceptionTest() throws Exception {
1369     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1370     mockDeviceManager.addException(exception);
1371 
1372     try {
1373       ResourceName resource = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1374       List<String> permissions = new ArrayList<>();
1375       client.testIamPermissions(resource, permissions);
1376       Assert.fail("No exception raised");
1377     } catch (InvalidArgumentException e) {
1378       // Expected exception.
1379     }
1380   }
1381 
1382   @Test
testIamPermissionsTest2()1383   public void testIamPermissionsTest2() throws Exception {
1384     TestIamPermissionsResponse expectedResponse =
1385         TestIamPermissionsResponse.newBuilder().addAllPermissions(new ArrayList<String>()).build();
1386     mockDeviceManager.addResponse(expectedResponse);
1387 
1388     String resource = "resource-341064690";
1389     List<String> permissions = new ArrayList<>();
1390 
1391     TestIamPermissionsResponse actualResponse = client.testIamPermissions(resource, permissions);
1392     Assert.assertEquals(expectedResponse, actualResponse);
1393 
1394     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1395     Assert.assertEquals(1, actualRequests.size());
1396     TestIamPermissionsRequest actualRequest = ((TestIamPermissionsRequest) actualRequests.get(0));
1397 
1398     Assert.assertEquals(resource, actualRequest.getResource());
1399     Assert.assertEquals(permissions, actualRequest.getPermissionsList());
1400     Assert.assertTrue(
1401         channelProvider.isHeaderSent(
1402             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1403             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1404   }
1405 
1406   @Test
testIamPermissionsExceptionTest2()1407   public void testIamPermissionsExceptionTest2() throws Exception {
1408     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1409     mockDeviceManager.addException(exception);
1410 
1411     try {
1412       String resource = "resource-341064690";
1413       List<String> permissions = new ArrayList<>();
1414       client.testIamPermissions(resource, permissions);
1415       Assert.fail("No exception raised");
1416     } catch (InvalidArgumentException e) {
1417       // Expected exception.
1418     }
1419   }
1420 
1421   @Test
sendCommandToDeviceTest()1422   public void sendCommandToDeviceTest() throws Exception {
1423     SendCommandToDeviceResponse expectedResponse = SendCommandToDeviceResponse.newBuilder().build();
1424     mockDeviceManager.addResponse(expectedResponse);
1425 
1426     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1427     ByteString binaryData = ByteString.EMPTY;
1428 
1429     SendCommandToDeviceResponse actualResponse = client.sendCommandToDevice(name, binaryData);
1430     Assert.assertEquals(expectedResponse, actualResponse);
1431 
1432     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1433     Assert.assertEquals(1, actualRequests.size());
1434     SendCommandToDeviceRequest actualRequest = ((SendCommandToDeviceRequest) actualRequests.get(0));
1435 
1436     Assert.assertEquals(name.toString(), actualRequest.getName());
1437     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
1438     Assert.assertTrue(
1439         channelProvider.isHeaderSent(
1440             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1441             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1442   }
1443 
1444   @Test
sendCommandToDeviceExceptionTest()1445   public void sendCommandToDeviceExceptionTest() throws Exception {
1446     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1447     mockDeviceManager.addException(exception);
1448 
1449     try {
1450       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1451       ByteString binaryData = ByteString.EMPTY;
1452       client.sendCommandToDevice(name, binaryData);
1453       Assert.fail("No exception raised");
1454     } catch (InvalidArgumentException e) {
1455       // Expected exception.
1456     }
1457   }
1458 
1459   @Test
sendCommandToDeviceTest2()1460   public void sendCommandToDeviceTest2() throws Exception {
1461     SendCommandToDeviceResponse expectedResponse = SendCommandToDeviceResponse.newBuilder().build();
1462     mockDeviceManager.addResponse(expectedResponse);
1463 
1464     String name = "name3373707";
1465     ByteString binaryData = ByteString.EMPTY;
1466 
1467     SendCommandToDeviceResponse actualResponse = client.sendCommandToDevice(name, binaryData);
1468     Assert.assertEquals(expectedResponse, actualResponse);
1469 
1470     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1471     Assert.assertEquals(1, actualRequests.size());
1472     SendCommandToDeviceRequest actualRequest = ((SendCommandToDeviceRequest) actualRequests.get(0));
1473 
1474     Assert.assertEquals(name, actualRequest.getName());
1475     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
1476     Assert.assertTrue(
1477         channelProvider.isHeaderSent(
1478             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1479             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1480   }
1481 
1482   @Test
sendCommandToDeviceExceptionTest2()1483   public void sendCommandToDeviceExceptionTest2() throws Exception {
1484     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1485     mockDeviceManager.addException(exception);
1486 
1487     try {
1488       String name = "name3373707";
1489       ByteString binaryData = ByteString.EMPTY;
1490       client.sendCommandToDevice(name, binaryData);
1491       Assert.fail("No exception raised");
1492     } catch (InvalidArgumentException e) {
1493       // Expected exception.
1494     }
1495   }
1496 
1497   @Test
sendCommandToDeviceTest3()1498   public void sendCommandToDeviceTest3() throws Exception {
1499     SendCommandToDeviceResponse expectedResponse = SendCommandToDeviceResponse.newBuilder().build();
1500     mockDeviceManager.addResponse(expectedResponse);
1501 
1502     DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1503     ByteString binaryData = ByteString.EMPTY;
1504     String subfolder = "subfolder153561774";
1505 
1506     SendCommandToDeviceResponse actualResponse =
1507         client.sendCommandToDevice(name, binaryData, subfolder);
1508     Assert.assertEquals(expectedResponse, actualResponse);
1509 
1510     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1511     Assert.assertEquals(1, actualRequests.size());
1512     SendCommandToDeviceRequest actualRequest = ((SendCommandToDeviceRequest) actualRequests.get(0));
1513 
1514     Assert.assertEquals(name.toString(), actualRequest.getName());
1515     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
1516     Assert.assertEquals(subfolder, actualRequest.getSubfolder());
1517     Assert.assertTrue(
1518         channelProvider.isHeaderSent(
1519             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1520             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1521   }
1522 
1523   @Test
sendCommandToDeviceExceptionTest3()1524   public void sendCommandToDeviceExceptionTest3() throws Exception {
1525     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1526     mockDeviceManager.addException(exception);
1527 
1528     try {
1529       DeviceName name = DeviceName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]", "[DEVICE]");
1530       ByteString binaryData = ByteString.EMPTY;
1531       String subfolder = "subfolder153561774";
1532       client.sendCommandToDevice(name, binaryData, subfolder);
1533       Assert.fail("No exception raised");
1534     } catch (InvalidArgumentException e) {
1535       // Expected exception.
1536     }
1537   }
1538 
1539   @Test
sendCommandToDeviceTest4()1540   public void sendCommandToDeviceTest4() throws Exception {
1541     SendCommandToDeviceResponse expectedResponse = SendCommandToDeviceResponse.newBuilder().build();
1542     mockDeviceManager.addResponse(expectedResponse);
1543 
1544     String name = "name3373707";
1545     ByteString binaryData = ByteString.EMPTY;
1546     String subfolder = "subfolder153561774";
1547 
1548     SendCommandToDeviceResponse actualResponse =
1549         client.sendCommandToDevice(name, binaryData, subfolder);
1550     Assert.assertEquals(expectedResponse, actualResponse);
1551 
1552     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1553     Assert.assertEquals(1, actualRequests.size());
1554     SendCommandToDeviceRequest actualRequest = ((SendCommandToDeviceRequest) actualRequests.get(0));
1555 
1556     Assert.assertEquals(name, actualRequest.getName());
1557     Assert.assertEquals(binaryData, actualRequest.getBinaryData());
1558     Assert.assertEquals(subfolder, actualRequest.getSubfolder());
1559     Assert.assertTrue(
1560         channelProvider.isHeaderSent(
1561             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1562             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1563   }
1564 
1565   @Test
sendCommandToDeviceExceptionTest4()1566   public void sendCommandToDeviceExceptionTest4() throws Exception {
1567     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1568     mockDeviceManager.addException(exception);
1569 
1570     try {
1571       String name = "name3373707";
1572       ByteString binaryData = ByteString.EMPTY;
1573       String subfolder = "subfolder153561774";
1574       client.sendCommandToDevice(name, binaryData, subfolder);
1575       Assert.fail("No exception raised");
1576     } catch (InvalidArgumentException e) {
1577       // Expected exception.
1578     }
1579   }
1580 
1581   @Test
bindDeviceToGatewayTest()1582   public void bindDeviceToGatewayTest() throws Exception {
1583     BindDeviceToGatewayResponse expectedResponse = BindDeviceToGatewayResponse.newBuilder().build();
1584     mockDeviceManager.addResponse(expectedResponse);
1585 
1586     RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1587     String gatewayId = "gatewayId-1354641793";
1588     String deviceId = "deviceId1109191185";
1589 
1590     BindDeviceToGatewayResponse actualResponse =
1591         client.bindDeviceToGateway(parent, gatewayId, deviceId);
1592     Assert.assertEquals(expectedResponse, actualResponse);
1593 
1594     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1595     Assert.assertEquals(1, actualRequests.size());
1596     BindDeviceToGatewayRequest actualRequest = ((BindDeviceToGatewayRequest) actualRequests.get(0));
1597 
1598     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1599     Assert.assertEquals(gatewayId, actualRequest.getGatewayId());
1600     Assert.assertEquals(deviceId, actualRequest.getDeviceId());
1601     Assert.assertTrue(
1602         channelProvider.isHeaderSent(
1603             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1604             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1605   }
1606 
1607   @Test
bindDeviceToGatewayExceptionTest()1608   public void bindDeviceToGatewayExceptionTest() throws Exception {
1609     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1610     mockDeviceManager.addException(exception);
1611 
1612     try {
1613       RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1614       String gatewayId = "gatewayId-1354641793";
1615       String deviceId = "deviceId1109191185";
1616       client.bindDeviceToGateway(parent, gatewayId, deviceId);
1617       Assert.fail("No exception raised");
1618     } catch (InvalidArgumentException e) {
1619       // Expected exception.
1620     }
1621   }
1622 
1623   @Test
bindDeviceToGatewayTest2()1624   public void bindDeviceToGatewayTest2() throws Exception {
1625     BindDeviceToGatewayResponse expectedResponse = BindDeviceToGatewayResponse.newBuilder().build();
1626     mockDeviceManager.addResponse(expectedResponse);
1627 
1628     String parent = "parent-995424086";
1629     String gatewayId = "gatewayId-1354641793";
1630     String deviceId = "deviceId1109191185";
1631 
1632     BindDeviceToGatewayResponse actualResponse =
1633         client.bindDeviceToGateway(parent, gatewayId, deviceId);
1634     Assert.assertEquals(expectedResponse, actualResponse);
1635 
1636     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1637     Assert.assertEquals(1, actualRequests.size());
1638     BindDeviceToGatewayRequest actualRequest = ((BindDeviceToGatewayRequest) actualRequests.get(0));
1639 
1640     Assert.assertEquals(parent, actualRequest.getParent());
1641     Assert.assertEquals(gatewayId, actualRequest.getGatewayId());
1642     Assert.assertEquals(deviceId, actualRequest.getDeviceId());
1643     Assert.assertTrue(
1644         channelProvider.isHeaderSent(
1645             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1646             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1647   }
1648 
1649   @Test
bindDeviceToGatewayExceptionTest2()1650   public void bindDeviceToGatewayExceptionTest2() throws Exception {
1651     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1652     mockDeviceManager.addException(exception);
1653 
1654     try {
1655       String parent = "parent-995424086";
1656       String gatewayId = "gatewayId-1354641793";
1657       String deviceId = "deviceId1109191185";
1658       client.bindDeviceToGateway(parent, gatewayId, deviceId);
1659       Assert.fail("No exception raised");
1660     } catch (InvalidArgumentException e) {
1661       // Expected exception.
1662     }
1663   }
1664 
1665   @Test
unbindDeviceFromGatewayTest()1666   public void unbindDeviceFromGatewayTest() throws Exception {
1667     UnbindDeviceFromGatewayResponse expectedResponse =
1668         UnbindDeviceFromGatewayResponse.newBuilder().build();
1669     mockDeviceManager.addResponse(expectedResponse);
1670 
1671     RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1672     String gatewayId = "gatewayId-1354641793";
1673     String deviceId = "deviceId1109191185";
1674 
1675     UnbindDeviceFromGatewayResponse actualResponse =
1676         client.unbindDeviceFromGateway(parent, gatewayId, deviceId);
1677     Assert.assertEquals(expectedResponse, actualResponse);
1678 
1679     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1680     Assert.assertEquals(1, actualRequests.size());
1681     UnbindDeviceFromGatewayRequest actualRequest =
1682         ((UnbindDeviceFromGatewayRequest) actualRequests.get(0));
1683 
1684     Assert.assertEquals(parent.toString(), actualRequest.getParent());
1685     Assert.assertEquals(gatewayId, actualRequest.getGatewayId());
1686     Assert.assertEquals(deviceId, actualRequest.getDeviceId());
1687     Assert.assertTrue(
1688         channelProvider.isHeaderSent(
1689             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1690             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1691   }
1692 
1693   @Test
unbindDeviceFromGatewayExceptionTest()1694   public void unbindDeviceFromGatewayExceptionTest() throws Exception {
1695     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1696     mockDeviceManager.addException(exception);
1697 
1698     try {
1699       RegistryName parent = RegistryName.of("[PROJECT]", "[LOCATION]", "[REGISTRY]");
1700       String gatewayId = "gatewayId-1354641793";
1701       String deviceId = "deviceId1109191185";
1702       client.unbindDeviceFromGateway(parent, gatewayId, deviceId);
1703       Assert.fail("No exception raised");
1704     } catch (InvalidArgumentException e) {
1705       // Expected exception.
1706     }
1707   }
1708 
1709   @Test
unbindDeviceFromGatewayTest2()1710   public void unbindDeviceFromGatewayTest2() throws Exception {
1711     UnbindDeviceFromGatewayResponse expectedResponse =
1712         UnbindDeviceFromGatewayResponse.newBuilder().build();
1713     mockDeviceManager.addResponse(expectedResponse);
1714 
1715     String parent = "parent-995424086";
1716     String gatewayId = "gatewayId-1354641793";
1717     String deviceId = "deviceId1109191185";
1718 
1719     UnbindDeviceFromGatewayResponse actualResponse =
1720         client.unbindDeviceFromGateway(parent, gatewayId, deviceId);
1721     Assert.assertEquals(expectedResponse, actualResponse);
1722 
1723     List<AbstractMessage> actualRequests = mockDeviceManager.getRequests();
1724     Assert.assertEquals(1, actualRequests.size());
1725     UnbindDeviceFromGatewayRequest actualRequest =
1726         ((UnbindDeviceFromGatewayRequest) actualRequests.get(0));
1727 
1728     Assert.assertEquals(parent, actualRequest.getParent());
1729     Assert.assertEquals(gatewayId, actualRequest.getGatewayId());
1730     Assert.assertEquals(deviceId, actualRequest.getDeviceId());
1731     Assert.assertTrue(
1732         channelProvider.isHeaderSent(
1733             ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
1734             GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
1735   }
1736 
1737   @Test
unbindDeviceFromGatewayExceptionTest2()1738   public void unbindDeviceFromGatewayExceptionTest2() throws Exception {
1739     StatusRuntimeException exception = new StatusRuntimeException(io.grpc.Status.INVALID_ARGUMENT);
1740     mockDeviceManager.addException(exception);
1741 
1742     try {
1743       String parent = "parent-995424086";
1744       String gatewayId = "gatewayId-1354641793";
1745       String deviceId = "deviceId1109191185";
1746       client.unbindDeviceFromGateway(parent, gatewayId, deviceId);
1747       Assert.fail("No exception raised");
1748     } catch (InvalidArgumentException e) {
1749       // Expected exception.
1750     }
1751   }
1752 }
1753