use of com.microsoft.azure.sdk.iot.service.exceptions.IotHubUnathorizedException in project azure-iot-sdk-java by Azure.
the class QueryTwinTests method rawQueryTokenRenewalWithAzureSasCredential.
@Test
@StandardTierHubOnlyTest
public void rawQueryTokenRenewalWithAzureSasCredential() throws IOException, InterruptedException, IotHubException, GeneralSecurityException, URISyntaxException, ModuleClientException {
IotHubConnectionString iotHubConnectionStringObj = IotHubConnectionStringBuilder.createIotHubConnectionString(iotHubConnectionString);
IotHubServiceSasToken serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
AzureSasCredential sasCredential = new AzureSasCredential(serviceSasToken.toString());
testInstance.twinServiceClient = new DeviceTwin(iotHubConnectionStringObj.getHostName(), sasCredential);
// test that the service client can query before the shared access signature expires
testRawQueryTwin();
// deliberately expire the SAS token to provoke a 401 to ensure that the registry manager is using the shared
// access signature that is set here.
sasCredential.update(SasTokenTools.makeSasTokenExpired(serviceSasToken.toString()));
try {
testRawQueryTwin();
fail("Expected query call to throw unauthorized exception since an expired SAS token was used, but no exception was thrown");
} catch (IotHubUnathorizedException e) {
log.debug("IotHubUnauthorizedException was thrown as expected, continuing test");
}
// Renew the expired shared access signature
serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
sasCredential.update(serviceSasToken.toString());
// test that the service client can query after renewing the shared access signature expires
testRawQueryTwin();
}
use of com.microsoft.azure.sdk.iot.service.exceptions.IotHubUnathorizedException in project azure-iot-sdk-java by Azure.
the class DeviceMethodTests method serviceClientTokenRenewalWithAzureSasCredential.
@Test
@StandardTierHubOnlyTest
public void serviceClientTokenRenewalWithAzureSasCredential() throws Exception {
if (testInstance.protocol != IotHubClientProtocol.AMQPS || testInstance.clientType != ClientType.DEVICE_CLIENT || testInstance.authenticationType != AuthenticationType.SAS) {
// This test is for the service client, so no need to rerun it for all the different client types or device protocols
return;
}
IotHubConnectionString iotHubConnectionStringObj = IotHubConnectionStringBuilder.createIotHubConnectionString(iotHubConnectionString);
IotHubServiceSasToken serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
AzureSasCredential sasCredential = new AzureSasCredential(serviceSasToken.toString());
this.testInstance.methodServiceClient = new DeviceMethod(iotHubConnectionStringObj.getHostName(), sasCredential, DeviceMethodClientOptions.builder().httpReadTimeout(HTTP_READ_TIMEOUT).build());
super.openDeviceClientAndSubscribeToMethods();
// add first device just to make sure that the first credential update worked
super.invokeMethodSucceed();
// deliberately expire the SAS token to provoke a 401 to ensure that the method client is using the shared
// access signature that is set here.
sasCredential.update(SasTokenTools.makeSasTokenExpired(serviceSasToken.toString()));
try {
super.invokeMethodSucceed();
fail("Expected invoke method call to throw unauthorized exception since an expired SAS token was used, but no exception was thrown");
} catch (IotHubUnathorizedException e) {
log.debug("IotHubUnauthorizedException was thrown as expected, continuing test");
}
// Renew the expired shared access signature
serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
sasCredential.update(serviceSasToken.toString());
// final method invocation should succeed since the shared access signature has been renewed
super.invokeMethodSucceed();
}
use of com.microsoft.azure.sdk.iot.service.exceptions.IotHubUnathorizedException in project azure-iot-sdk-java by Azure.
the class ServiceClientTests method serviceClientTokenRenewalWithAzureSasCredential.
@Test
@StandardTierHubOnlyTest
public void serviceClientTokenRenewalWithAzureSasCredential() throws Exception {
RegistryManager registryManager = new RegistryManager(iotHubConnectionString, RegistryManagerOptions.builder().httpReadTimeout(HTTP_READ_TIMEOUT).build());
TestDeviceIdentity testDeviceIdentity = Tools.getTestDevice(iotHubConnectionString, IotHubClientProtocol.AMQPS, AuthenticationType.SAS, false);
Device device = testDeviceIdentity.getDevice();
ServiceClient serviceClient;
IotHubConnectionString iotHubConnectionStringObj = IotHubConnectionStringBuilder.createIotHubConnectionString(iotHubConnectionString);
IotHubServiceSasToken serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
AzureSasCredential sasCredential = new AzureSasCredential(serviceSasToken.toString());
serviceClient = new ServiceClient(iotHubConnectionStringObj.getHostName(), sasCredential, testInstance.protocol);
serviceClient.open();
Message message = new Message(SMALL_PAYLOAD);
serviceClient.send(device.getDeviceId(), message);
// deliberately expire the SAS token to provoke a 401 to ensure that the registry manager is using the shared
// access signature that is set here.
sasCredential.update(SasTokenTools.makeSasTokenExpired(serviceSasToken.toString()));
try {
serviceClient.send(device.getDeviceId(), message);
fail("Expected sending cloud to device message to throw unauthorized exception since an expired SAS token was used, but no exception was thrown");
} catch (IOException e) {
// For service client, the unauthorized exception is wrapped by an IOException, so we need to unwrap it here
if (e.getCause() instanceof IotHubUnathorizedException) {
log.debug("IotHubUnauthorizedException was thrown as expected, continuing test");
} else {
throw e;
}
}
// Renew the expired shared access signature
serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
sasCredential.update(serviceSasToken.toString());
// The final c2d send should succeed since the shared access signature has been renewed
serviceClient.send(device.getDeviceId(), message);
serviceClient.close();
registryManager.close();
Tools.disposeTestIdentity(testDeviceIdentity, iotHubConnectionString);
}
use of com.microsoft.azure.sdk.iot.service.exceptions.IotHubUnathorizedException in project azure-iot-sdk-java by Azure.
the class JobClientTests method jobClientTokenRenewalWithAzureSasCredential.
@Test(timeout = TEST_TIMEOUT_MILLISECONDS)
public void jobClientTokenRenewalWithAzureSasCredential() throws InterruptedException, IOException, IotHubException {
// Arrange
IotHubConnectionString iotHubConnectionStringObj = IotHubConnectionStringBuilder.createIotHubConnectionString(iotHubConnectionString);
IotHubServiceSasToken serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
AzureSasCredential sasCredential = new AzureSasCredential(serviceSasToken.toString());
JobClient jobClientWithSasCredential = new JobClient(iotHubConnectionStringObj.getHostName(), sasCredential);
// JobClient usage should succeed since the shared access signature hasn't expired yet
scheduleDeviceMethod(jobClientWithSasCredential);
// deliberately expire the SAS token to provoke a 401 to ensure that the job client is using the shared
// access signature that is set here.
sasCredential.update(SasTokenTools.makeSasTokenExpired(serviceSasToken.toString()));
try {
scheduleDeviceMethod(jobClientWithSasCredential);
fail("Expected scheduling a job to throw unauthorized exception since an expired SAS token was used, but no exception was thrown");
} catch (IotHubUnathorizedException e) {
log.debug("IotHubUnauthorizedException was thrown as expected, continuing test");
}
// Renew the expired shared access signature
serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
sasCredential.update(serviceSasToken.toString());
// JobClient usage should succeed since the shared access signature has been renewed
scheduleDeviceMethod(jobClientWithSasCredential);
}
use of com.microsoft.azure.sdk.iot.service.exceptions.IotHubUnathorizedException in project azure-iot-sdk-java by Azure.
the class RegistryManagerTests method registryManagerTokenRenewalWithAzureSasCredential.
@Test
public void registryManagerTokenRenewalWithAzureSasCredential() throws Exception {
IotHubConnectionString iotHubConnectionStringObj = IotHubConnectionStringBuilder.createIotHubConnectionString(iotHubConnectionString);
IotHubServiceSasToken serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
AzureSasCredential azureSasCredential = new AzureSasCredential(serviceSasToken.toString());
RegistryManager registryManager = new RegistryManager(iotHubConnectionStringObj.getHostName(), azureSasCredential);
RegistryManagerTestInstance testInstance = new RegistryManagerTestInstance(registryManager);
Device device1 = Device.createDevice(testInstance.deviceId + "-1", AuthenticationType.SAS);
Device device2 = Device.createDevice(testInstance.deviceId + "-2", AuthenticationType.SAS);
Device device3 = Device.createDevice(testInstance.deviceId + "-3", AuthenticationType.SAS);
azureSasCredential.update(serviceSasToken.toString());
// add first device just to make sure that the first credential update worked
testInstance.registryManager.addDevice(device1);
// deliberately expire the SAS token to provoke a 401 to ensure that the registry manager is using the shared
// access signature that is set here.
azureSasCredential.update(SasTokenTools.makeSasTokenExpired(serviceSasToken.toString()));
try {
testInstance.registryManager.addDevice(device2);
fail("Expected adding a device to throw unauthorized exception since an expired SAS token was used, but no exception was thrown");
} catch (IotHubUnathorizedException e) {
log.debug("IotHubUnauthorizedException was thrown as expected, continuing test");
}
// Renew the expired shared access signature
serviceSasToken = new IotHubServiceSasToken(iotHubConnectionStringObj);
azureSasCredential.update(serviceSasToken.toString());
// adding the final device should succeed since the shared access signature has been renewed
testInstance.registryManager.addDevice(device3);
}
Aggregations