public async Task UpdateInvalidIdentityWithTokenTest()
{
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(dc => dc.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(GetMockDeviceClient())
.Throws(new UnauthorizedException("Unauthorized"));
var transportSettings = new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) };
var messageConverterProvider = new MessageConverterProvider(new Dictionary <Type, IMessageConverter> {
[typeof(TwinCollection)] = Mock.Of <IMessageConverter>()
});
ITokenCredentials identity1 = GetMockClientCredentialsWithToken();
ClientTokenCloudConnection cloudConnection = await ClientTokenCloudConnection.Create(
identity1,
(_, __) => { },
transportSettings,
messageConverterProvider,
deviceClientProvider.Object,
Mock.Of <ICloudListener>(),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
Option <ICloudProxy> cloudProxy1 = cloudConnection.CloudProxy;
Assert.True(cloudProxy1.HasValue);
Assert.True(cloudProxy1.OrDefault().IsActive);
ITokenCredentials identity2 = GetMockClientCredentialsWithToken();
await Assert.ThrowsAsync <UnauthorizedException>(() => cloudConnection.UpdateTokenAsync(identity2));
Assert.True(cloudProxy1.OrDefault().IsActive);
}
public async Task GetCloudConnectionForIdentityWithTokenTest()
{
IClientProvider clientProvider = GetMockDeviceClientProviderWithToken();
var transportSettings = new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) };
var messageConverterProvider = new MessageConverterProvider(new Dictionary <Type, IMessageConverter> {
[typeof(TwinCollection)] = Mock.Of <IMessageConverter>()
});
ITokenCredentials clientCredentials1 = GetMockClientCredentialsWithToken();
ClientTokenCloudConnection cloudConnection = await ClientTokenCloudConnection.Create(
clientCredentials1,
(_, __) => { },
transportSettings,
messageConverterProvider,
clientProvider,
Mock.Of <ICloudListener>(),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
Option <ICloudProxy> cloudProxy1 = cloudConnection.CloudProxy;
Assert.True(cloudProxy1.HasValue);
Assert.True(cloudProxy1.OrDefault().IsActive);
ITokenCredentials clientCredentials2 = GetMockClientCredentialsWithToken();
ICloudProxy cloudProxy2 = await cloudConnection.UpdateTokenAsync(clientCredentials2);
Assert.Equal(cloudProxy2, cloudConnection.CloudProxy.OrDefault());
Assert.True(cloudProxy2.IsActive);
Assert.False(cloudProxy1.OrDefault().IsActive);
Assert.NotEqual(cloudProxy1.OrDefault(), cloudProxy2);
}
public async Task CloudConnectionCallbackTest()
{
int receivedConnectedStatusCount = 0;
ConnectionStatusChangesHandler connectionStatusChangesHandler = (_, __) => { };
IClient GetMockedDeviceClient()
{
var deviceClient = new Mock <IClient>();
deviceClient.SetupGet(dc => dc.IsActive).Returns(true);
deviceClient.Setup(dc => dc.CloseAsync())
.Callback(() => deviceClient.SetupGet(dc => dc.IsActive).Returns(false))
.Returns(Task.FromResult(true));
deviceClient.Setup(dc => dc.SetConnectionStatusChangedHandler(It.IsAny <ConnectionStatusChangesHandler>()))
.Callback <ConnectionStatusChangesHandler>(c => connectionStatusChangesHandler = c);
deviceClient.Setup(dc => dc.OpenAsync())
.Callback(
() =>
{
Assert.NotNull(connectionStatusChangesHandler);
connectionStatusChangesHandler.Invoke(ConnectionStatus.Connected, ConnectionStatusChangeReason.Connection_Ok);
})
.Returns(Task.CompletedTask);
return(deviceClient.Object);
}
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(dc => dc.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(() => GetMockedDeviceClient());
var transportSettings = new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) };
void ConnectionStatusHandler(string id, CloudConnectionStatus status)
{
if (status == CloudConnectionStatus.ConnectionEstablished)
{
receivedConnectedStatusCount++;
}
}
var messageConverterProvider = new MessageConverterProvider(new Dictionary <Type, IMessageConverter> {
[typeof(TwinCollection)] = Mock.Of <IMessageConverter>()
});
ITokenCredentials clientCredentialsWithExpiringToken1 = GetMockClientCredentialsWithToken();
ClientTokenCloudConnection cloudConnection = await ClientTokenCloudConnection.Create(
clientCredentialsWithExpiringToken1,
ConnectionStatusHandler,
transportSettings,
messageConverterProvider,
deviceClientProvider.Object,
Mock.Of <ICloudListener>(),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
Assert.Equal(receivedConnectedStatusCount, 1);
Option <ICloudProxy> cloudProxy1 = cloudConnection.CloudProxy;
Assert.True(cloudProxy1.HasValue);
Assert.True(cloudProxy1.OrDefault().IsActive);
Assert.NotNull(connectionStatusChangesHandler);
connectionStatusChangesHandler.Invoke(ConnectionStatus.Connected, ConnectionStatusChangeReason.Connection_Ok);
Assert.Equal(receivedConnectedStatusCount, 2);
ITokenCredentials clientCredentialsWithExpiringToken2 = GetMockClientCredentialsWithToken();
ICloudProxy cloudProxy2 = await cloudConnection.UpdateTokenAsync(clientCredentialsWithExpiringToken2);
Assert.True(cloudProxy2.IsActive);
Assert.Equal(cloudProxy2, cloudConnection.CloudProxy.OrDefault());
Assert.Equal(receivedConnectedStatusCount, 2);
connectionStatusChangesHandler.Invoke(ConnectionStatus.Connected, ConnectionStatusChangeReason.Connection_Ok);
Assert.Equal(receivedConnectedStatusCount, 3);
}
public async Task RefreshTokenWithRetryTest()
{
string iothubHostName = "test.azure-devices.net";
string deviceId = "device1";
ITokenCredentials GetClientCredentialsWithExpiringToken()
{
string token = TokenHelper.CreateSasToken(iothubHostName, DateTime.UtcNow.AddMinutes(3));
var identity = new DeviceIdentity(iothubHostName, deviceId);
return(new TokenCredentials(identity, token, string.Empty, false));
}
ITokenCredentials GetClientCredentialsWithNonExpiringToken()
{
string token = TokenHelper.CreateSasToken(iothubHostName, DateTime.UtcNow.AddMinutes(10));
var identity = new DeviceIdentity(iothubHostName, deviceId);
return(new TokenCredentials(identity, token, string.Empty, false));
}
ITokenProvider tokenProvider = null;
IClientProvider clientProvider = GetMockDeviceClientProviderWithToken((s, a, t) => tokenProvider = a);
var transportSettings = new ITransportSettings[] { new AmqpTransportSettings(TransportType.Amqp_Tcp_Only) };
var receivedStatuses = new List <CloudConnectionStatus>();
void ConnectionStatusHandler(string id, CloudConnectionStatus status) => receivedStatuses.Add(status);
var messageConverterProvider = new MessageConverterProvider(new Dictionary <Type, IMessageConverter> {
[typeof(TwinCollection)] = Mock.Of <IMessageConverter>()
});
ITokenCredentials clientCredentialsWithExpiringToken1 = GetClientCredentialsWithExpiringToken();
ClientTokenCloudConnection cloudConnection = await ClientTokenCloudConnection.Create(
clientCredentialsWithExpiringToken1,
ConnectionStatusHandler,
transportSettings,
messageConverterProvider,
clientProvider,
Mock.Of <ICloudListener>(),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
Option <ICloudProxy> cloudProxy1 = cloudConnection.CloudProxy;
Assert.True(cloudProxy1.HasValue);
Assert.True(cloudProxy1.OrDefault().IsActive);
Assert.NotNull(tokenProvider);
// Try to refresh token but get an expiring token
Task <string> getTokenTask = tokenProvider.GetTokenAsync(Option.None <TimeSpan>());
Assert.False(getTokenTask.IsCompleted);
Assert.Equal(1, receivedStatuses.Count);
Assert.Equal(receivedStatuses[0], CloudConnectionStatus.TokenNearExpiry);
ICloudProxy cloudProxy2 = await cloudConnection.UpdateTokenAsync(clientCredentialsWithExpiringToken1);
// Wait for the task to process
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.False(getTokenTask.IsCompletedSuccessfully);
Assert.Equal(cloudProxy2, cloudConnection.CloudProxy.OrDefault());
Assert.True(cloudProxy2.IsActive);
Assert.True(cloudProxy1.OrDefault().IsActive);
Assert.Equal(cloudProxy1.OrDefault(), cloudProxy2);
// Wait for 20 secs for retry to happen
await Task.Delay(TimeSpan.FromSeconds(20));
// Check if retry happened
Assert.Equal(2, receivedStatuses.Count);
Assert.Equal(receivedStatuses[1], CloudConnectionStatus.TokenNearExpiry);
ITokenCredentials clientCredentialsWithNonExpiringToken = GetClientCredentialsWithNonExpiringToken();
ICloudProxy cloudProxy3 = await cloudConnection.UpdateTokenAsync(clientCredentialsWithNonExpiringToken);
// Wait for the task to complete
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.True(getTokenTask.IsCompletedSuccessfully);
Assert.Equal(cloudProxy3, cloudConnection.CloudProxy.OrDefault());
Assert.True(cloudProxy3.IsActive);
Assert.True(cloudProxy1.OrDefault().IsActive);
Assert.Equal(cloudProxy1.OrDefault(), cloudProxy3);
Assert.Equal(getTokenTask.Result, clientCredentialsWithNonExpiringToken.Token);
}