public async Task ConnectWithInvalidConnectionStringTest()
{
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), TokenProvider, DeviceScopeIdentitiesCache, TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity1 = Mock.Of <IIdentity>(m => m.Id == "device1");
var clientCredentials1 = new SharedKeyCredentials(deviceIdentity1, "dummyConnStr", null);
Try <ICloudConnection> result = await cloudConnectionProvider.Connect(clientCredentials1, null);
Assert.False(result.Success);
Assert.IsType <AggregateException>(result.Exception);
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
// Change the connection string key, deliberately.
char updatedLastChar = (char)(deviceConnectionString[deviceConnectionString.Length - 1] + 1);
deviceConnectionString = deviceConnectionString.Substring(0, deviceConnectionString.Length - 1) + updatedLastChar;
var deviceIdentity2 = Mock.Of <IIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials2 = new SharedKeyCredentials(deviceIdentity2, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials2, null).Result;
Assert.False(cloudProxy.Success);
}
async Task <ICloudProxy> GetCloudProxyWithConnectionStringKey(string connectionStringConfigKey, IEdgeHub edgeHub)
{
const int ConnectionPoolSize = 10;
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey(connectionStringConfigKey);
var converters = new MessageConverterProvider(new Dictionary <Type, IMessageConverter>()
{
{ typeof(Client.Message), new DeviceClientMessageConverter() },
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(converters, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60), true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, string.Empty);
Try <ICloudConnection> cloudConnection = await cloudConnectionProvider.Connect(clientCredentials, (_, __) => { });
Assert.True(cloudConnection.Success);
Assert.True(cloudConnection.Value.IsActive);
Assert.True(cloudConnection.Value.CloudProxy.HasValue);
return(cloudConnection.Value.CloudProxy.OrDefault());
}
public async Task CloudConnectionUpdateTest()
{
ITokenProvider receivedTokenProvider = null;
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Callback <IIdentity, ITokenProvider, ITransportSettings[]>((i, s, t) => receivedTokenProvider = s)
.Returns(GetDeviceClient);
var productInfoStore = Mock.Of <IProductInfoStore>();
var credentialsCache = Mock.Of <ICredentialsCache>();
var edgeHubIdentity = Mock.Of <IIdentity>(i => i.Id == "edgeDevice/$edgeHub");
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
string token1 = TokenHelper.CreateSasToken("foo.azure-devices.net", DateTime.UtcNow.AddHours(2));
var deviceCredentials = new TokenCredentials(new DeviceIdentity("iotHub", "Device1"), token1, DummyProductInfo, true);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
await connectionManager.AddDeviceConnection(deviceCredentials.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.NotNull(receivedTokenProvider);
Assert.Equal(token1, receivedTokenProvider.GetTokenAsync(Option.None <TimeSpan>()).Result);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
string token2 = TokenHelper.CreateSasToken("foo.azure-devices.net", DateTime.UtcNow.AddHours(2));
deviceCredentials = new TokenCredentials(new DeviceIdentity("iotHub", "Device1"), token2, DummyProductInfo, true);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(receivedCloudProxy2.Success);
Assert.NotNull(receivedCloudProxy2.Value);
Assert.True(receivedCloudProxy2.Value.IsActive);
Assert.False(receivedCloudProxy1.Value.IsActive);
Assert.NotNull(receivedTokenProvider);
Assert.Equal(token2, receivedTokenProvider.GetTokenAsync(Option.None <TimeSpan>()).Result);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
}
public async Task ConnectUsingIdentityInScopeTest()
{
// Arrange
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
var deviceServiceIdentity = new ServiceIdentity(deviceIdentity.Id, "1234", new string[0], new ServiceAuthentication(ServiceAuthenticationType.CertificateAuthority), ServiceIdentityStatus.Enabled);
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(It.Is <string>(i => i == deviceIdentity.Id), false))
.ReturnsAsync(Option.Some(deviceServiceIdentity));
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
CredentialsCache,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
cloudConnectionProvider.BindEdgeHub(edgeHub);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(deviceIdentity, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
deviceScopeIdentitiesCache.VerifyAll();
}
public async Task CreateCloudProxyTest()
{
string edgeDeviceId = "edgeDevice";
string module1Id = "module1";
var module1Credentials = new TokenCredentials(new ModuleIdentity("iotHub", edgeDeviceId, module1Id), "token", DummyProductInfo, false);
IClient client1 = GetDeviceClient();
IClient client2 = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(client1)
.Returns(client2);
var credentialsCache = Mock.Of <ICredentialsCache>();
var edgeHubIdentity = Mock.Of <IIdentity>(i => i.Id == "edgeDevice/$edgeHub");
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>());
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
Task <Try <ICloudProxy> > getCloudProxyTask1 = connectionManager.CreateCloudConnectionAsync(module1Credentials);
Task <Try <ICloudProxy> > getCloudProxyTask2 = connectionManager.CreateCloudConnectionAsync(module1Credentials);
Try <ICloudProxy>[] cloudProxies = await Task.WhenAll(getCloudProxyTask1, getCloudProxyTask2);
Assert.NotEqual(cloudProxies[0].Value, cloudProxies[1].Value);
Option <ICloudProxy> currentCloudProxyId1 = await connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
ICloudProxy currentCloudProxy = currentCloudProxyId1.OrDefault();
ICloudProxy cloudProxy1 = cloudProxies[0].Value;
ICloudProxy cloudProxy2 = cloudProxies[1].Value;
Assert.True(currentCloudProxy == cloudProxy1 || currentCloudProxy == cloudProxy2);
if (currentCloudProxy == cloudProxy1)
{
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Never);
}
else
{
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Never);
}
}
public async Task ConnectUsingTokenCredentialsTest()
{
// Arrange
var productInfoStore = Mock.Of <IProductInfoStore>();
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
DeviceScopeIdentitiesCache,
CredentialsCache,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, false);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(tokenCreds, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
}
public async Task GetCloudProxyTest()
{
// Arrange
string edgeDeviceId = "edgeDevice";
string module1Id = "module1";
string iotHub = "foo.azure-devices.net";
string token = TokenHelper.CreateSasToken(iotHub);
var module1Credentials = new TokenCredentials(new ModuleIdentity(iotHub, edgeDeviceId, module1Id), token, DummyProductInfo, true);
IClient client1 = GetDeviceClient();
IClient client2 = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(client1)
.Returns(client2);
ICredentialsCache credentialsCache = new CredentialsCache(new NullCredentialsCache());
await credentialsCache.Add(module1Credentials);
var productInfoStore = Mock.Of <IProductInfoStore>();
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
new ModuleIdentity(iotHub, edgeDeviceId, "$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
// Act
Option <ICloudProxy> getCloudProxyTask = await connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
// Assert
Assert.True(getCloudProxyTask.HasValue);
Assert.True(getCloudProxyTask.OrDefault().IsActive);
// Act
await getCloudProxyTask.OrDefault().CloseAsync();
Option <ICloudProxy> newCloudProxyTask1 = await connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
// Assert
Assert.True(newCloudProxyTask1.HasValue);
Assert.NotEqual(newCloudProxyTask1.OrDefault(), getCloudProxyTask.OrDefault());
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Never);
}
public async Task ConnectUsingInvalidTokenCredentialsTest()
{
// Arrange
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.OpenAsync()).ThrowsAsync(new TimeoutException());
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(dc => dc.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>(), Option.None <string>()))
.Returns(deviceClient.Object);
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var edgeHub = Mock.Of <IEdgeHub>();
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
CredentialsCache,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
true,
true,
true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.Some(deviceIdentity.Id));
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(tokenCreds, null);
// Assert
Assert.False(cloudProxy.Success);
Assert.IsType <TimeoutException>(cloudProxy.Exception);
}
public async Task CloudConnectionInvalidUpdateTest()
{
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(GetDeviceClient())
.Throws(new UnauthorizedException("connstr2 is invalid!"))
.Throws(new UnauthorizedException("connstr2 is invalid!"));
var productInfoStore = Mock.Of <IProductInfoStore>();
var credentialsCache = Mock.Of <ICredentialsCache>();
var edgeHubIdentity = Mock.Of <IIdentity>(i => i.Id == "edgeDevice/$edgeHub");
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
string token1 = TokenHelper.CreateSasToken("foo.azure-devices.net", DateTime.UtcNow.AddHours(2));
var deviceCredentials1 = new TokenCredentials(new DeviceIdentity("iotHub", "Device1"), token1, DummyProductInfo, true);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials1);
await connectionManager.AddDeviceConnection(deviceCredentials1.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials1.Identity.Id).OrDefault());
string token2 = TokenHelper.CreateSasToken("foo.azure-devices.net", DateTime.UtcNow.AddHours(2));
var deviceCredentials2 = new TokenCredentials(new DeviceIdentity("iotHub", "Device1"), token2, DummyProductInfo, true);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials2);
Assert.False(receivedCloudProxy2.Success);
Assert.IsType <EdgeHubConnectionException>(receivedCloudProxy2.Exception);
Assert.IsType <UnauthorizedException>(receivedCloudProxy2.Exception.InnerException);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials2.Identity.Id).OrDefault());
}
async Task <ICloudProxy> GetCloudProxyFromConnectionStringKey(string connectionStringConfigKey, IEdgeHub edgeHub)
{
const int ConnectionPoolSize = 10;
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey(connectionStringConfigKey);
string deviceId = ConnectionStringHelper.GetDeviceId(deviceConnectionString);
string iotHubHostName = ConnectionStringHelper.GetHostName(deviceConnectionString);
string sasKey = ConnectionStringHelper.GetSharedAccessKey(deviceConnectionString);
var converters = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var credentialsCache = Mock.Of <ICredentialsCache>();
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
converters,
ConnectionPoolSize,
new ClientProvider(Option.None <string>()),
Option.None <UpstreamProtocol>(),
Mock.Of <Util.ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
Mock.Of <IIdentity>(i => i.Id == $"{deviceId}/$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
true,
true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var clientTokenProvider = new ClientTokenProvider(new SharedAccessKeySignatureProvider(sasKey), iotHubHostName, deviceId, TimeSpan.FromHours(1));
string token = await clientTokenProvider.GetTokenAsync(Option.None <TimeSpan>());
var deviceIdentity = new DeviceIdentity(iotHubHostName, deviceId);
var clientCredentials = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
Try <ICloudConnection> cloudConnection = await cloudConnectionProvider.Connect(clientCredentials, (_, __) => { });
Assert.True(cloudConnection.Success);
Assert.True(cloudConnection.Value.IsActive);
Assert.True(cloudConnection.Value.CloudProxy.HasValue);
return(cloudConnection.Value.CloudProxy.OrDefault());
}
public async Task ConnectUsingIdentityInCacheTest()
{
// Arrange
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
var deviceServiceIdentity = new ServiceIdentity(deviceIdentity.Id, "1234", new string[0], new ServiceAuthentication(ServiceAuthenticationType.CertificateAuthority), ServiceIdentityStatus.Disabled);
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.Some(deviceServiceIdentity));
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.Some(deviceIdentity.Id));
var credentialsCache = new Mock <ICredentialsCache>(MockBehavior.Strict);
credentialsCache.Setup(c => c.Get(deviceIdentity)).ReturnsAsync(Option.Some((IClientCredentials)tokenCreds));
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
scopeAuthenticationOnly: false,
trackDeviceState: false,
nestedEdgeEnabled: true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(deviceIdentity, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
deviceScopeIdentitiesCache.VerifyAll();
credentialsCache.VerifyAll();
}
public async Task Connect_ScopeOnly_TokenCredentials()
{
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.None <ServiceIdentity>());
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.Some(deviceIdentity.Id));
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var edgeHub = Mock.Of <IEdgeHub>();
var credentialsCache = new Mock <ICredentialsCache>(MockBehavior.Strict);
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
credentialsCache.Setup(cc => cc.Get(deviceIdentity)).ReturnsAsync(Option.Some <IClientCredentials>(tokenCreds));
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
scopeAuthenticationOnly: true,
trackDeviceState: false);
cloudConnectionProvider.BindEdgeHub(edgeHub);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(deviceIdentity, null);
// Assert
Assert.Throws <InvalidOperationException>(() => cloudProxy.Value);
deviceScopeIdentitiesCache.VerifyAll();
credentialsCache.Verify(cc => cc.Get(It.IsAny <IIdentity>()), Times.Never);
}
public async Task ConnectTest()
{
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(MessageConverterProvider, ConnectionPoolSize, new ClientProvider(), Option.None <UpstreamProtocol>(), TokenProvider, DeviceScopeIdentitiesCache, TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(edgeHub);
string deviceConnectionString = await SecretsHelper.GetSecretFromConfigKey("device1ConnStrKey");
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == ConnectionStringHelper.GetDeviceId(deviceConnectionString));
var clientCredentials = new SharedKeyCredentials(deviceIdentity, deviceConnectionString, null);
Try <ICloudConnection> cloudProxy = cloudConnectionProvider.Connect(clientCredentials, null).Result;
Assert.True(cloudProxy.Success);
bool result = await cloudProxy.Value.CloseAsync();
Assert.True(result);
}
public async Task ConnectUsingIdentityInCacheTest2()
{
// Arrange
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, false);
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(It.Is <string>(i => i == deviceIdentity.Id), false))
.ReturnsAsync(Option.None <ServiceIdentity>());
var credentialsCache = new Mock <ICredentialsCache>(MockBehavior.Strict);
credentialsCache.Setup(c => c.Get(deviceIdentity)).ReturnsAsync(Option.Some((IClientCredentials)tokenCreds));
var productInfoStore = Mock.Of <IProductInfoStore>();
var modelIdStore = Mock.Of <IModelIdStore>();
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
productInfoStore,
modelIdStore);
cloudConnectionProvider.BindEdgeHub(edgeHub);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(deviceIdentity, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
deviceScopeIdentitiesCache.VerifyAll();
credentialsCache.VerifyAll();
}
public async Task ConnectUsingIdentityInScope_DeviceInvalidStateException_WithRecover(bool isNested)
{
// Arrange
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
var deviceServiceIdentity = new ServiceIdentity(deviceIdentity.Id, "1234", new string[0], new ServiceAuthentication(ServiceAuthenticationType.CertificateAuthority), ServiceIdentityStatus.Disabled);
deviceScopeIdentitiesCache.Setup(d => d.VerifyServiceIdentityAuthChainState(It.Is <string>(i => i == deviceIdentity.Id), isNested, false))
.ThrowsAsync(new DeviceInvalidStateException());
deviceScopeIdentitiesCache.Setup(d => d.VerifyServiceIdentityAuthChainState(It.Is <string>(i => i == deviceIdentity.Id), isNested, true))
.ReturnsAsync(deviceIdentity.Id);
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var edgeHub = Mock.Of <IEdgeHub>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
CredentialsCache,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
scopeAuthenticationOnly: true,
trackDeviceState: true,
nestedEdgeEnabled: isNested);
cloudConnectionProvider.BindEdgeHub(edgeHub);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(deviceIdentity, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
deviceScopeIdentitiesCache.VerifyAll();
}
public async Task CloudConnectionInvalidUpdateTest()
{
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Returns(GetDeviceClient())
.Throws(new UnauthorizedException("connstr2 is invalid!"))
.Throws(new UnauthorizedException("connstr2 is invalid!"));
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, EdgeDeviceId, EdgeModuleId);
string deviceConnStr1 = "connstr1";
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr1, DummyProductInfo);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
await connectionManager.AddDeviceConnection(deviceCredentials.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
string deviceConnStr2 = "connstr2";
deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr2, DummyProductInfo);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.False(receivedCloudProxy2.Success);
Assert.IsType <EdgeHubConnectionException>(receivedCloudProxy2.Exception);
List <Exception> innerExceptions = (receivedCloudProxy2.Exception.InnerException as AggregateException)?.InnerExceptions.ToList() ?? new List <Exception>();
Assert.Equal(2, innerExceptions.Count);
Assert.IsType <UnauthorizedException>(innerExceptions[0]);
Assert.IsType <UnauthorizedException>(innerExceptions[1]);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
}
public async Task ConnectUsingTokenCredentialsTest()
{
// Arrange
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var edgeHub = Mock.Of <IEdgeHub>();
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>(MockBehavior.Strict);
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
MessageConverterProvider,
ConnectionPoolSize,
GetMockDeviceClientProvider(),
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
CredentialsCache,
EdgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
true,
true,
true);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var deviceIdentity = Mock.Of <IDeviceIdentity>(m => m.Id == "d1");
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == deviceIdentity.Id)))
.ReturnsAsync(Option.Some(deviceIdentity.Id));
string token = TokenHelper.CreateSasToken(IotHubHostName, DateTime.UtcNow.AddMinutes(10));
var tokenCreds = new TokenCredentials(deviceIdentity, token, string.Empty, Option.None <string>(), Option.None <string>(), false);
// Act
Try <ICloudConnection> cloudProxy = await cloudConnectionProvider.Connect(tokenCreds, null);
// Assert
Assert.True(cloudProxy.Success);
Assert.NotNull(cloudProxy.Value);
}
public async Task CloudConnectionUpdateTest()
{
string receivedConnStr = null;
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Callback <IIdentity, string, Client.ITransportSettings[]>((i, s, t) => receivedConnStr = s)
.Returns(() => GetDeviceClient());
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), Mock.Of <ITokenProvider>(), Mock.Of <IDeviceScopeIdentitiesCache>(), TimeSpan.FromMinutes(60));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, EdgeDeviceId, EdgeModuleId);
string deviceConnStr1 = "connstr1";
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr1, DummyProductInfo);
var deviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
Try <ICloudProxy> receivedCloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
await connectionManager.AddDeviceConnection(deviceCredentials.Identity, deviceProxy);
Assert.True(receivedCloudProxy1.Success);
Assert.NotNull(receivedCloudProxy1.Value);
Assert.True(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceConnStr1, receivedConnStr);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
string deviceConnStr2 = "connstr2";
deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", "Device1"), deviceConnStr2, DummyProductInfo);
Try <ICloudProxy> receivedCloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(receivedCloudProxy2.Success);
Assert.NotNull(receivedCloudProxy2.Value);
Assert.True(receivedCloudProxy2.Value.IsActive);
Assert.False(receivedCloudProxy1.Value.IsActive);
Assert.Equal(deviceConnStr2, receivedConnStr);
Assert.Equal(deviceProxy, connectionManager.GetDeviceConnection(deviceCredentials.Identity.Id).OrDefault());
}
public async Task GetMultipleCloudProxiesTest()
{
// Arrange
string edgeDeviceId = "edgeDevice";
string module1Id = "module1";
string token = TokenHelper.CreateSasToken(IotHubHostName);
var module1Credentials = new TokenCredentials(new ModuleIdentity(IotHubHostName, edgeDeviceId, module1Id), token, DummyProductInfo, true);
IClient client1 = GetDeviceClient();
IClient client2 = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(client1)
.Returns(client2);
ICredentialsCache credentialsCache = new CredentialsCache(new NullCredentialsCache());
await credentialsCache.Add(module1Credentials);
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
new ModuleIdentity(IotHubHostName, edgeDeviceId, "$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20));
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
// Act
Task <Option <ICloudProxy> > getCloudProxyTask1 = connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
Task <Option <ICloudProxy> > getCloudProxyTask2 = connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
Task <Option <ICloudProxy> > getCloudProxyTask3 = connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
Task <Option <ICloudProxy> > getCloudProxyTask4 = connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
Option <ICloudProxy>[] cloudProxies = await Task.WhenAll(getCloudProxyTask1, getCloudProxyTask2, getCloudProxyTask3, getCloudProxyTask4);
// Assert
Assert.True(cloudProxies[0].HasValue);
Assert.True(cloudProxies[1].HasValue);
Assert.True(cloudProxies[2].HasValue);
Assert.True(cloudProxies[3].HasValue);
Assert.Equal(cloudProxies[0].OrDefault(), cloudProxies[1].OrDefault());
Assert.Equal(cloudProxies[0].OrDefault(), cloudProxies[2].OrDefault());
Assert.Equal(cloudProxies[0].OrDefault(), cloudProxies[3].OrDefault());
// Act
await cloudProxies[0].OrDefault().CloseAsync();
Option <ICloudProxy> newCloudProxyTask1 = await connectionManager.GetCloudConnection(module1Credentials.Identity.Id);
// Assert
Assert.True(newCloudProxyTask1.HasValue);
Assert.NotEqual(newCloudProxyTask1.OrDefault(), cloudProxies[0].OrDefault());
Mock.Get(client1).Verify(cp => cp.CloseAsync(), Times.Once);
Mock.Get(client2).Verify(cp => cp.CloseAsync(), Times.Never);
}
public async Task UpdateDeviceConnectionTest()
{
int receivedConnectedStatusCount = 0;
ConnectionStatusChangesHandler connectionStatusChangesHandler = null;
string hostname = "dummy.azure-devices.net";
string deviceId = "device1";
IClientCredentials GetClientCredentials(TimeSpan tokenExpiryDuration)
{
string token = TokenHelper.CreateSasToken(hostname, DateTime.UtcNow.AddSeconds(tokenExpiryDuration.TotalSeconds));
var identity = new DeviceIdentity(hostname, deviceId);
return(new TokenCredentials(identity, token, string.Empty));
}
IDeviceProxy GetMockDeviceProxy()
{
var deviceProxyMock1 = new Mock <IDeviceProxy>();
deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(true);
deviceProxyMock1.Setup(dp => dp.CloseAsync(It.IsAny <Exception>()))
.Callback(() => deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(false))
.Returns(Task.CompletedTask);
return(deviceProxyMock1.Object);
}
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(() =>
{
int currentCount = receivedConnectedStatusCount;
Assert.NotNull(connectionStatusChangesHandler);
connectionStatusChangesHandler.Invoke(ConnectionStatus.Connected, ConnectionStatusChangeReason.Connection_Ok);
Assert.Equal(receivedConnectedStatusCount, currentCount);
})
.Returns(Task.CompletedTask);
return(deviceClient.Object);
}
IAuthenticationMethod authenticationMethod = null;
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(dc => dc.Create(It.IsAny <IIdentity>(), It.IsAny <IAuthenticationMethod>(), It.IsAny <ITransportSettings[]>()))
.Callback <IIdentity, IAuthenticationMethod, ITransportSettings[]>((s, a, t) => authenticationMethod = a)
.Returns(() => GetMockedDeviceClient());
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>(), TokenProvider, DeviceScopeIdentitiesCache, TimeSpan.FromMinutes(60), true);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var credentialsCache = Mock.Of <ICredentialsCache>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, deviceId, "$edgeHub");
IClientCredentials clientCredentials1 = GetClientCredentials(TimeSpan.FromSeconds(10));
Try <ICloudProxy> cloudProxyTry1 = await connectionManager.CreateCloudConnectionAsync(clientCredentials1);
Assert.True(cloudProxyTry1.Success);
IDeviceProxy deviceProxy1 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials1.Identity, deviceProxy1);
await Task.Delay(TimeSpan.FromSeconds(10));
Assert.NotNull(authenticationMethod);
var deviceTokenRefresher = authenticationMethod as DeviceAuthenticationWithTokenRefresh;
Assert.NotNull(deviceTokenRefresher);
Task <string> tokenGetter = deviceTokenRefresher.GetTokenAsync(hostname);
Assert.False(tokenGetter.IsCompleted);
IClientCredentials clientCredentials2 = GetClientCredentials(TimeSpan.FromMinutes(2));
Try <ICloudProxy> cloudProxyTry2 = await connectionManager.CreateCloudConnectionAsync(clientCredentials2);
Assert.True(cloudProxyTry2.Success);
IDeviceProxy deviceProxy2 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials2.Identity, deviceProxy2);
await Task.Delay(TimeSpan.FromSeconds(3));
Assert.False(tokenGetter.IsCompleted);
IClientCredentials clientCredentials3 = GetClientCredentials(TimeSpan.FromMinutes(10));
Try <ICloudProxy> cloudProxyTry3 = await connectionManager.CreateCloudConnectionAsync(clientCredentials3);
Assert.True(cloudProxyTry3.Success);
IDeviceProxy deviceProxy3 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials3.Identity, deviceProxy3);
await Task.Delay(TimeSpan.FromSeconds(23));
Assert.True(tokenGetter.IsCompleted);
Assert.Equal(tokenGetter.Result, (clientCredentials3 as ITokenCredentials)?.Token);
}
public async Task TestEdgeHubConnection()
{
const string EdgeDeviceId = "testHubEdgeDevice1";
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
string iotHubConnectionString = await SecretsHelper.GetSecretFromConfigKey("iotHubConnStrKey");
IotHubConnectionStringBuilder iotHubConnectionStringBuilder = IotHubConnectionStringBuilder.Create(iotHubConnectionString);
RegistryManager registryManager = RegistryManager.CreateFromConnectionString(iotHubConnectionString);
await registryManager.OpenAsync();
string iothubHostName = iotHubConnectionStringBuilder.HostName;
var identityProvider = new IdentityProvider(iothubHostName);
var identityFactory = new ClientCredentialsFactory(identityProvider);
(string edgeDeviceId, string deviceConnStr) = await RegistryManagerHelper.CreateDevice(EdgeDeviceId, iotHubConnectionString, registryManager, true, false);
string edgeHubConnectionString = $"{deviceConnStr};ModuleId={EdgeHubModuleId}";
IClientCredentials edgeHubCredentials = identityFactory.GetWithConnectionString(edgeHubConnectionString);
string sasKey = ConnectionStringHelper.GetSharedAccessKey(deviceConnStr);
var signatureProvider = new SharedAccessKeySignatureProvider(sasKey);
var credentialsCache = Mock.Of <ICredentialsCache>();
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
new ClientProvider(),
Option.None <UpstreamProtocol>(),
new ClientTokenProvider(signatureProvider, iothubHostName, edgeDeviceId, TimeSpan.FromMinutes(60)),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
edgeHubCredentials.Identity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), identityProvider, deviceConnectivityManager);
try
{
Mock.Get(credentialsCache)
.Setup(c => c.Get(edgeHubCredentials.Identity))
.ReturnsAsync(Option.Some(edgeHubCredentials));
Assert.NotNull(edgeHubCredentials);
Assert.NotNull(edgeHubCredentials.Identity);
// Set Edge hub desired properties
await this.SetDesiredProperties(registryManager, edgeDeviceId);
var endpointFactory = new EndpointFactory(connectionManager, new RoutingMessageConverter(), edgeDeviceId, 10, 10);
var routeFactory = new EdgeRouteFactory(endpointFactory);
var dbStoreProvider = new InMemoryDbStoreProvider();
IStoreProvider storeProvider = new StoreProvider(dbStoreProvider);
IEntityStore <string, TwinInfo> twinStore = storeProvider.GetEntityStore <string, TwinInfo>("twins");
var twinManager = new TwinManager(connectionManager, twinCollectionMessageConverter, twinMessageConverter, Option.Some(twinStore));
var routerConfig = new RouterConfig(Enumerable.Empty <Route>());
TimeSpan defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorFactory = new SyncEndpointExecutorFactory(new EndpointExecutorConfig(defaultTimeout, new FixedInterval(0, TimeSpan.FromSeconds(1)), defaultTimeout, true));
Router router = await Router.CreateAsync(Guid.NewGuid().ToString(), iothubHostName, routerConfig, endpointExecutorFactory);
IInvokeMethodHandler invokeMethodHandler = new InvokeMethodHandler(connectionManager);
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
IEdgeHub edgeHub = new RoutingEdgeHub(router, new RoutingMessageConverter(), connectionManager, twinManager, edgeDeviceId, invokeMethodHandler, subscriptionProcessor);
cloudConnectionProvider.BindEdgeHub(edgeHub);
var versionInfo = new VersionInfo("v1", "b1", "c1");
// Create Edge Hub connection
EdgeHubConnection edgeHubConnection = await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
TwinConfigSource configSource = new TwinConfigSource(edgeHubConnection, edgeHubCredentials.Identity.Id, versionInfo, twinManager, twinMessageConverter, twinCollectionMessageConverter, routeFactory);
// Get and Validate EdgeHubConfig
Option <EdgeHubConfig> edgeHubConfigOption = await configSource.GetConfig();
Assert.True(edgeHubConfigOption.HasValue);
EdgeHubConfig edgeHubConfig = edgeHubConfigOption.OrDefault();
Assert.Equal("1.0", edgeHubConfig.SchemaVersion);
Assert.NotNull(edgeHubConfig.Routes);
Assert.NotNull(edgeHubConfig.StoreAndForwardConfiguration);
Assert.Equal(20, edgeHubConfig.StoreAndForwardConfiguration.TimeToLiveSecs);
IReadOnlyDictionary <string, RouteConfig> routes = edgeHubConfig.Routes;
Assert.Equal(4, routes.Count);
RouteConfig route1 = routes["route1"];
Assert.True(route1.Route.Endpoint.GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
RouteConfig route2 = routes["route2"];
Endpoint endpoint = route2.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
RouteConfig route3 = routes["route3"];
endpoint = route3.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module3/input1", endpoint.Id);
Assert.Equal("route3", route3.Name);
Assert.Equal("from /modules/module2 INTO BrokeredEndpoint(\"/modules/module3/inputs/input1\")", route3.Value);
RouteConfig route4 = routes["route4"];
endpoint = route4.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module4/input1", endpoint.Id);
Assert.Equal("route4", route4.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module4/inputs/input1\")", route4.Value);
// Make sure reported properties were updated appropriately
EdgeHubConnection.ReportedProperties reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(0, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Simulate a module and a downstream device that connects to Edge Hub.
string moduleId = "module1";
string sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{edgeDeviceId}/modules/{moduleId}");
string moduleConnectionstring = $"HostName={iothubHostName};DeviceId={edgeDeviceId};ModuleId={moduleId};SharedAccessSignature={sasToken}";
IClientCredentials moduleClientCredentials = identityFactory.GetWithConnectionString(moduleConnectionstring);
var moduleProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
string downstreamDeviceId = "device1";
sasToken = TokenHelper.CreateSasToken($"{iothubHostName}/devices/{downstreamDeviceId}");
string downstreamDeviceConnectionstring = $"HostName={iothubHostName};DeviceId={downstreamDeviceId};SharedAccessSignature={sasToken}";
IClientCredentials downstreamDeviceCredentials = identityFactory.GetWithConnectionString(downstreamDeviceConnectionstring);
var downstreamDeviceProxy = Mock.Of <IDeviceProxy>(d => d.IsActive);
// Connect the module and downstream device and make sure the reported properties are updated as expected.
await connectionManager.AddDeviceConnection(moduleClientCredentials.Identity, moduleProxy);
await connectionManager.AddDeviceConnection(downstreamDeviceCredentials.Identity, downstreamDeviceProxy);
string moduleIdKey = $"{edgeDeviceId}/{moduleId}";
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(ConnectionStatus.Connected, reportedProperties.Clients[downstreamDeviceId].Status);
Assert.NotNull(reportedProperties.Clients[downstreamDeviceId].LastConnectedTimeUtc);
Assert.Null(reportedProperties.Clients[downstreamDeviceId].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Update desired propertied and make sure callback is called with valid values
bool callbackCalled = false;
Task ConfigUpdatedCallback(EdgeHubConfig updatedConfig)
{
Assert.NotNull(updatedConfig);
Assert.NotNull(updatedConfig.StoreAndForwardConfiguration);
Assert.NotNull(updatedConfig.Routes);
routes = updatedConfig.Routes;
Assert.Equal(4, routes.Count);
route1 = routes["route1"];
Assert.True(route1.Route.Endpoint.GetType() == typeof(CloudEndpoint));
Assert.Equal("route1", route1.Name);
Assert.Equal("from /* INTO $upstream", route1.Value);
route2 = routes["route2"];
endpoint = route2.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module2/input1", endpoint.Id);
Assert.Equal("route2", route2.Name);
Assert.Equal("from /modules/module1 INTO BrokeredEndpoint(\"/modules/module2/inputs/input1\")", route2.Value);
route3 = routes["route4"];
endpoint = route3.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module5/input1", endpoint.Id);
Assert.Equal("route4", route3.Name);
Assert.Equal("from /modules/module3 INTO BrokeredEndpoint(\"/modules/module5/inputs/input1\")", route3.Value);
route4 = routes["route5"];
endpoint = route4.Route.Endpoint;
Assert.True(endpoint.GetType() == typeof(ModuleEndpoint));
Assert.Equal($"{edgeDeviceId}/module6/input1", endpoint.Id);
Assert.Equal("route5", route4.Name);
Assert.Equal("from /modules/module5 INTO BrokeredEndpoint(\"/modules/module6/inputs/input1\")", route4.Value);
callbackCalled = true;
return(Task.CompletedTask);
}
configSource.SetConfigUpdatedCallback(ConfigUpdatedCallback);
await this.UpdateDesiredProperties(registryManager, edgeDeviceId);
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.True(callbackCalled);
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.NotNull(reportedProperties.Clients);
Assert.Equal(2, reportedProperties.Clients.Count);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// Disconnect the downstream device and make sure the reported properties are updated as expected.
await connectionManager.RemoveDeviceConnection(moduleIdKey);
await connectionManager.RemoveDeviceConnection(downstreamDeviceId);
await Task.Delay(TimeSpan.FromSeconds(10));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Equal(1, reportedProperties.Clients.Count);
Assert.True(reportedProperties.Clients.ContainsKey(moduleIdKey));
Assert.False(reportedProperties.Clients.ContainsKey(downstreamDeviceId));
Assert.Equal(ConnectionStatus.Disconnected, reportedProperties.Clients[moduleIdKey].Status);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastConnectedTimeUtc);
Assert.NotNull(reportedProperties.Clients[moduleIdKey].LastDisconnectTimeUtc);
Assert.Equal(200, reportedProperties.LastDesiredStatus.Code);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
// If the edge hub restarts, clear out the connected devices in the reported properties.
await EdgeHubConnection.Create(
edgeHubCredentials.Identity,
edgeHub,
twinManager,
connectionManager,
routeFactory,
twinCollectionMessageConverter,
versionInfo,
new NullDeviceScopeIdentitiesCache());
await Task.Delay(TimeSpan.FromMinutes(1));
reportedProperties = await this.GetReportedProperties(registryManager, edgeDeviceId);
Assert.Null(reportedProperties.Clients);
Assert.Equal("1.0", reportedProperties.SchemaVersion);
Assert.Equal(versionInfo, reportedProperties.VersionInfo);
}
finally
{
try
{
await RegistryManagerHelper.RemoveDevice(edgeDeviceId, registryManager);
}
catch (Exception)
{
// ignored
}
}
}
public async Task CloudConnectionTest()
{
// ReSharper disable once PossibleUnintendedReferenceComparison
var deviceCredentials1 = Mock.Of <ITokenCredentials>(c => c.Identity == Mock.Of <IIdentity>(d => d.Id == "Device1"));
// ReSharper disable once PossibleUnintendedReferenceComparison
var deviceCredentials2 = Mock.Of <ITokenCredentials>(c => c.Identity == Mock.Of <IIdentity>(d => d.Id == "Device2"));
string edgeDeviceId = "edgeDevice";
IClient client1 = GetDeviceClient();
IClient client2 = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.SetupSequence(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(client1)
.Returns(client2);
var productInfoStore = Mock.Of <IProductInfoStore>();
ICredentialsCache credentialsCache = new CredentialsCache(new NullCredentialsCache());
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsCache,
new ModuleIdentity(IotHubHostName, edgeDeviceId, "$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache, GetIdentityProvider());
Option <ICloudProxy> returnedValue = await connectionManager.GetCloudConnection(deviceCredentials1.Identity.Id);
Assert.False(returnedValue.HasValue);
Try <ICloudProxy> cloudProxy1 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials1);
Assert.True(cloudProxy1.Success);
Assert.True(cloudProxy1.Value.IsActive);
returnedValue = await connectionManager.GetCloudConnection(deviceCredentials1.Identity.Id);
Assert.True(returnedValue.HasValue);
Assert.Equal(((RetryingCloudProxy)cloudProxy1.Value).InnerCloudProxy, ((RetryingCloudProxy)returnedValue.OrDefault()).InnerCloudProxy);
Try <ICloudProxy> cloudProxy2 = await connectionManager.CreateCloudConnectionAsync(deviceCredentials2);
Assert.True(cloudProxy2.Success);
Assert.True(cloudProxy2.Value.IsActive);
await connectionManager.RemoveDeviceConnection(deviceCredentials2.Identity.Id);
returnedValue = await connectionManager.GetCloudConnection(deviceCredentials2.Identity.Id);
Assert.True(returnedValue.HasValue);
}
public async Task TestAddRemoveDeviceConnectionTest()
{
string deviceId = "id1";
var deviceProxyMock1 = new Mock <IDeviceProxy>();
deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(true);
deviceProxyMock1.Setup(dp => dp.CloseAsync(It.IsAny <Exception>()))
.Callback(() => deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(false))
.Returns(Task.FromResult(true));
var deviceCredentials = new SharedKeyCredentials(new DeviceIdentity("iotHub", deviceId), "dummyConnStr", "abc");
var edgeHub = new Mock <IEdgeHub>();
IClient client = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <string>(), It.IsAny <Client.ITransportSettings[]>()))
.Returns(client);
var cloudConnectionProvider = new CloudConnectionProvider(messageConverterProvider, 1, deviceClientProvider.Object, Option.None <UpstreamProtocol>());
cloudConnectionProvider.BindEdgeHub(edgeHub.Object);
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider);
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(cloudProxyTry.Success);
var deviceListener = new DeviceMessageHandler(deviceCredentials.Identity, edgeHub.Object, connectionManager);
Option <ICloudProxy> cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
await connectionManager.AddDeviceConnection(deviceCredentials);
deviceListener.BindDeviceProxy(deviceProxyMock1.Object);
Option <IDeviceProxy> deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.True(deviceProxy.HasValue);
Assert.True(deviceProxy.OrDefault().IsActive);
Assert.True(deviceProxyMock1.Object.IsActive);
cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
await deviceListener.CloseAsync();
deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.False(deviceProxy.HasValue);
Assert.False(deviceProxyMock1.Object.IsActive);
cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(client.IsActive);
}
public async Task UpdateDeviceConnectionTest()
{
int receivedConnectedStatusCount = 0;
ConnectionStatusChangesHandler connectionStatusChangesHandler = null;
string hostname = "dummy.azure-devices.net";
string deviceId = "device1";
ITokenCredentials GetClientCredentials(TimeSpan tokenExpiryDuration)
{
string token = TokenHelper.CreateSasToken(hostname, DateTime.UtcNow.AddSeconds(tokenExpiryDuration.TotalSeconds));
var identity = new DeviceIdentity(hostname, deviceId);
return(new TokenCredentials(identity, token, string.Empty, Option.None <string>(), Option.None <string>(), false));
}
IDeviceProxy GetMockDeviceProxy()
{
var deviceProxyMock1 = new Mock <IDeviceProxy>();
deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(true);
deviceProxyMock1.Setup(dp => dp.CloseAsync(It.IsAny <Exception>()))
.Callback(() => deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(false))
.Returns(Task.CompletedTask);
return(deviceProxyMock1.Object);
}
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(
() =>
{
int currentCount = receivedConnectedStatusCount;
Assert.NotNull(connectionStatusChangesHandler);
connectionStatusChangesHandler.Invoke(ConnectionStatus.Connected, ConnectionStatusChangeReason.Connection_Ok);
Assert.Equal(receivedConnectedStatusCount, currentCount);
})
.Returns(Task.CompletedTask);
return(deviceClient.Object);
}
ITokenProvider tokenProvider = null;
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(dc => dc.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>(), Option.None <string>()))
.Callback <IIdentity, ITokenProvider, ITransportSettings[], Option <string> >((s, a, t, m) => tokenProvider = a)
.Returns(GetMockedDeviceClient);
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(m => m.GetMetadata(It.IsAny <string>())).ReturnsAsync(new ConnectionMetadata("dummyValue"));
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>();
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == deviceId))).ReturnsAsync(Option.Some(deviceId));
var credentialsCache = Mock.Of <ICredentialsCache>();
ICloudConnectionProvider cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
TokenProvider,
deviceScopeIdentitiesCache.Object,
credentialsCache,
Mock.Of <IIdentity>(i => i.Id == $"{deviceId}/$edgeHub"),
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
scopeAuthenticationOnly: true,
trackDeviceState: true,
true);
cloudConnectionProvider.BindEdgeHub(Mock.Of <IEdgeHub>());
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), new IdentityProvider(hostname), deviceConnectivityManager);
ITokenCredentials clientCredentials1 = GetClientCredentials(TimeSpan.FromSeconds(10));
Try <ICloudProxy> cloudProxyTry1 = await connectionManager.CreateCloudConnectionAsync(clientCredentials1);
Assert.True(cloudProxyTry1.Success);
IDeviceProxy deviceProxy1 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials1.Identity, deviceProxy1);
await Task.Delay(TimeSpan.FromSeconds(10));
Assert.NotNull(tokenProvider);
Task <string> tokenGetter = tokenProvider.GetTokenAsync(Option.None <TimeSpan>());
Assert.False(tokenGetter.IsCompleted);
ITokenCredentials clientCredentials2 = GetClientCredentials(TimeSpan.FromMinutes(2));
Try <ICloudProxy> cloudProxyTry2 = await connectionManager.CreateCloudConnectionAsync(clientCredentials2);
Assert.True(cloudProxyTry2.Success);
IDeviceProxy deviceProxy2 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials2.Identity, deviceProxy2);
await Task.Delay(TimeSpan.FromSeconds(3));
Assert.False(tokenGetter.IsCompleted);
ITokenCredentials clientCredentials3 = GetClientCredentials(TimeSpan.FromMinutes(10));
Try <ICloudProxy> cloudProxyTry3 = await connectionManager.CreateCloudConnectionAsync(clientCredentials3);
Assert.True(cloudProxyTry3.Success);
IDeviceProxy deviceProxy3 = GetMockDeviceProxy();
await connectionManager.AddDeviceConnection(clientCredentials3.Identity, deviceProxy3);
await Task.Delay(TimeSpan.FromSeconds(23));
Assert.True(tokenGetter.IsCompleted);
Assert.Equal(tokenGetter.Result, clientCredentials3.Token);
}
public async Task TestAddRemoveDeviceConnectionTest()
{
string deviceId = "id1";
var deviceProxyMock1 = new Mock <IDeviceProxy>();
deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(true);
deviceProxyMock1.Setup(dp => dp.CloseAsync(It.IsAny <Exception>()))
.Callback(() => deviceProxyMock1.SetupGet(dp => dp.IsActive).Returns(false))
.Returns(Task.FromResult(true));
var deviceCredentials = new TokenCredentials(new DeviceIdentity("iotHub", deviceId), "token", "abc", false);
var edgeHub = new Mock <IEdgeHub>();
IClient client = GetDeviceClient();
var messageConverterProvider = Mock.Of <IMessageConverterProvider>();
var deviceClientProvider = new Mock <IClientProvider>();
deviceClientProvider.Setup(d => d.Create(It.IsAny <IIdentity>(), It.IsAny <ITokenProvider>(), It.IsAny <ITransportSettings[]>()))
.Returns(client);
var productInfoStore = Mock.Of <IProductInfoStore>();
var credentialsManager = Mock.Of <ICredentialsCache>();
var edgeHubIdentity = Mock.Of <IIdentity>(i => i.Id == "edgeDevice/$edgeHub");
var cloudConnectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
deviceClientProvider.Object,
Option.None <UpstreamProtocol>(),
Mock.Of <ITokenProvider>(),
Mock.Of <IDeviceScopeIdentitiesCache>(),
credentialsManager,
edgeHubIdentity,
TimeSpan.FromMinutes(60),
true,
TimeSpan.FromSeconds(20),
Option.None <IWebProxy>(),
productInfoStore);
cloudConnectionProvider.BindEdgeHub(edgeHub.Object);
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsManager, GetIdentityProvider());
Try <ICloudProxy> cloudProxyTry = await connectionManager.CreateCloudConnectionAsync(deviceCredentials);
Assert.True(cloudProxyTry.Success);
var deviceListener = new DeviceMessageHandler(deviceCredentials.Identity, edgeHub.Object, connectionManager);
Option <ICloudProxy> cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
deviceListener.BindDeviceProxy(deviceProxyMock1.Object);
Option <IDeviceProxy> deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.True(deviceProxy.HasValue);
Assert.True(deviceProxy.OrDefault().IsActive);
Assert.True(deviceProxyMock1.Object.IsActive);
cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(cloudProxy.OrDefault().IsActive);
await deviceListener.CloseAsync();
deviceProxy = connectionManager.GetDeviceConnection(deviceId);
Assert.False(deviceProxy.HasValue);
Assert.False(deviceProxyMock1.Object.IsActive);
cloudProxy = await connectionManager.GetCloudConnection(deviceId);
Assert.True(cloudProxy.HasValue);
Assert.True(client.IsActive);
}
public async Task TestMultipleOperations()
{
// Arrange
const string Id = "id1";
var identity = Mock.Of <IIdentity>(i => i.Id == Id);
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Shared.Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
var edgeHubTokenProvider = new Mock <ITokenProvider>();
var clientWatcher = new ClientWatcher();
var clientProvider = new Mock <IClientProvider>();
clientProvider.Setup(c => c.Create(identity, edgeHubTokenProvider.Object, It.IsAny <ITransportSettings[]>()))
.Returns(() => new ThrowingClient(clientWatcher, 15));
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>();
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(Id, false))
.ReturnsAsync(
Option.Some(
new ServiceIdentity(
Id,
"dummy",
new List <string>(),
new ServiceAuthentication(new SymmetricKeyAuthentication("foo", "bar")),
ServiceIdentityStatus.Enabled)));
var edgeHubIdentity = Mock.Of <IIdentity>();
var productInfoStore = new Mock <IProductInfoStore>();
productInfoStore.Setup(p => p.GetEdgeProductInfo(Id))
.ReturnsAsync("ProdInfo1");
var identityProvider = new Mock <IIdentityProvider>();
identityProvider.Setup(i => i.Create(Id)).Returns(identity);
var credentialsCache = new Mock <ICredentialsCache>();
var edgeHub = new Mock <IEdgeHub>();
var connectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
clientProvider.Object,
Option.None <UpstreamProtocol>(),
edgeHubTokenProvider.Object,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
edgeHubIdentity,
TimeSpan.FromMinutes(10),
false,
TimeSpan.FromMinutes(10),
Option.None <IWebProxy>(),
productInfoStore.Object);
connectionProvider.BindEdgeHub(edgeHub.Object);
var connectionManager = new ConnectionManager(connectionProvider, credentialsCache.Object, identityProvider.Object);
async Task <ICloudProxy> GetCloudProxy(IConnectionManager cm)
{
// Act
Option <ICloudProxy> cloudProxyOption = await cm.GetCloudConnection(Id);
// Assert
Assert.True(cloudProxyOption.HasValue);
ICloudProxy cloudProxy = cloudProxyOption.OrDefault();
Assert.True(cloudProxy.IsActive);
return(cloudProxy);
}
var messagesToSend = new List <IMessage>();
for (int i = 0; i < 60; i++)
{
var message = new EdgeMessage.Builder(new byte[i])
.SetSystemProperties(
new Dictionary <string, string>()
{
[SystemProperties.MessageId] = i.ToString()
})
.Build();
messagesToSend.Add(message);
}
// Act
ICloudProxy cloudProxy1 = await GetCloudProxy(connectionManager);
ICloudProxy cloudProxy2 = await GetCloudProxy(connectionManager);
ICloudProxy cloudProxy3 = await GetCloudProxy(connectionManager);
// Act
var tasks = new[]
{
RunGetTwin(cloudProxy1, 10),
RunGetTwin(cloudProxy2, 30),
RunGetTwin(cloudProxy3, 10),
RunSendMessages(cloudProxy1, messagesToSend.Take(20), 2),
RunSendMessages(cloudProxy2, messagesToSend.Skip(20).Take(10)),
RunSendMessages(cloudProxy3, messagesToSend.Skip(30).Take(30), 3)
};
await Task.WhenAll(tasks);
// Assert
Assert.Equal(50, clientWatcher.GetTwinCount);
List <string> expectedMessageIds = messagesToSend
.Select(m => m.SystemProperties[SystemProperties.MessageId])
.OrderBy(s => s)
.ToList();
List <string> receivedMessageIds = clientWatcher.ReceivedMessages
.Select(m => m.MessageId)
.OrderBy(s => s)
.ToList();
Assert.Equal(expectedMessageIds.Count, receivedMessageIds.Count);
Assert.Equal(expectedMessageIds, receivedMessageIds);
}
public async Task TestGetTwin()
{
// Arrange
const string Id = "id1";
var identity = Mock.Of <IIdentity>(i => i.Id == Id);
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Shared.Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
var edgeHubTokenProvider = new Mock <ITokenProvider>();
var clientWatcher = new ClientWatcher();
var clientProvider = new Mock <IClientProvider>();
clientProvider.Setup(c => c.Create(identity, edgeHubTokenProvider.Object, It.IsAny <ITransportSettings[]>(), Option.None <string>()))
.Returns(() => new ThrowingClient(clientWatcher, 3));
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>();
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(Id))
.ReturnsAsync(
Option.Some(
new ServiceIdentity(
Id,
"dummy",
new List <string>(),
new ServiceAuthentication(new SymmetricKeyAuthentication("foo", "bar")),
ServiceIdentityStatus.Enabled)));
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == Id)))
.ReturnsAsync(Option.Some(Id));
var edgeHubIdentity = Mock.Of <IIdentity>();
ConnectionMetadata connectionMetadata = new ConnectionMetadata("edgeProdInfo");
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(p => p.GetMetadata(Id))
.ReturnsAsync(connectionMetadata);
var identityProvider = new Mock <IIdentityProvider>();
identityProvider.Setup(i => i.Create(Id)).Returns(identity);
var credentialsCache = new Mock <ICredentialsCache>();
var edgeHub = new Mock <IEdgeHub>();
var connectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
clientProvider.Object,
Option.None <UpstreamProtocol>(),
edgeHubTokenProvider.Object,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
edgeHubIdentity,
TimeSpan.FromMinutes(10),
false,
TimeSpan.FromMinutes(10),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
true);
connectionProvider.BindEdgeHub(edgeHub.Object);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var connectionManager = new ConnectionManager(connectionProvider, credentialsCache.Object, identityProvider.Object, deviceConnectivityManager);
// Act
Option <ICloudProxy> cloudProxyOption = await connectionManager.GetCloudConnection(Id);
// Assert
Assert.True(cloudProxyOption.HasValue);
ICloudProxy cloudProxy = cloudProxyOption.OrDefault();
Assert.True(cloudProxy.IsActive);
// Act
await RunGetTwin(cloudProxy, 10);
// Assert
Assert.Equal(5, clientWatcher.OpenAsyncCount);
Assert.True(cloudProxy.IsActive);
Assert.Equal(10, clientWatcher.GetTwinCount);
}
public async Task TestSendMessages()
{
// Arrange
const string Id = "id1";
var identity = Mock.Of <IIdentity>(i => i.Id == Id);
var twinMessageConverter = new TwinMessageConverter();
var twinCollectionMessageConverter = new TwinCollectionMessageConverter();
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Message), new DeviceClientMessageConverter() },
{ typeof(Shared.Twin), twinMessageConverter },
{ typeof(TwinCollection), twinCollectionMessageConverter }
});
var edgeHubTokenProvider = new Mock <ITokenProvider>();
var clientWatcher = new ClientWatcher();
var clientProvider = new Mock <IClientProvider>();
clientProvider.Setup(c => c.Create(identity, edgeHubTokenProvider.Object, It.IsAny <ITransportSettings[]>(), Option.None <string>()))
.Returns(() => new ThrowingClient(clientWatcher, 3));
var deviceScopeIdentitiesCache = new Mock <IDeviceScopeIdentitiesCache>();
deviceScopeIdentitiesCache.Setup(d => d.GetServiceIdentity(Id))
.ReturnsAsync(
Option.Some(
new ServiceIdentity(
Id,
"dummy",
new List <string>(),
new ServiceAuthentication(new SymmetricKeyAuthentication("foo", "bar")),
ServiceIdentityStatus.Enabled)));
deviceScopeIdentitiesCache.Setup(d => d.GetAuthChain(It.Is <string>(i => i == Id)))
.ReturnsAsync(Option.Some(Id));
var edgeHubIdentity = Mock.Of <IIdentity>();
ConnectionMetadata connectionMetadata = new ConnectionMetadata("edgeProdInfo");
var metadataStore = new Mock <IMetadataStore>();
metadataStore.Setup(p => p.GetMetadata(Id))
.ReturnsAsync(connectionMetadata);
var identityProvider = new Mock <IIdentityProvider>();
identityProvider.Setup(i => i.Create(Id)).Returns(identity);
var credentialsCache = new Mock <ICredentialsCache>();
var edgeHub = new Mock <IEdgeHub>();
var connectionProvider = new CloudConnectionProvider(
messageConverterProvider,
1,
clientProvider.Object,
Option.None <UpstreamProtocol>(),
edgeHubTokenProvider.Object,
deviceScopeIdentitiesCache.Object,
credentialsCache.Object,
edgeHubIdentity,
TimeSpan.FromMinutes(10),
false,
TimeSpan.FromMinutes(10),
false,
Option.None <IWebProxy>(),
metadataStore.Object,
scopeAuthenticationOnly: true,
trackDeviceState: true,
true);
connectionProvider.BindEdgeHub(edgeHub.Object);
var deviceConnectivityManager = Mock.Of <IDeviceConnectivityManager>();
var connectionManager = new ConnectionManager(connectionProvider, credentialsCache.Object, identityProvider.Object, deviceConnectivityManager);
var messagesToSend = new List <IMessage>();
for (int i = 0; i < 10; i++)
{
var message = new EdgeMessage.Builder(new byte[i])
.SetSystemProperties(
new Dictionary <string, string>()
{
[SystemProperties.MessageId] = i.ToString()
})
.Build();
messagesToSend.Add(message);
}
// Act
Option <ICloudProxy> cloudProxyOption = await connectionManager.GetCloudConnection(Id);
// Assert
Assert.True(cloudProxyOption.HasValue);
ICloudProxy cloudProxy = cloudProxyOption.OrDefault();
Assert.True(cloudProxy.IsActive);
// Act
await RunSendMessages(cloudProxy, messagesToSend);
// Assert
Assert.Equal(messagesToSend.Count, clientWatcher.ReceivedMessages.Count());
Assert.Equal(5, clientWatcher.OpenAsyncCount);
Assert.True(cloudProxy.IsActive);
IEnumerable <string> expectedMessageIds = messagesToSend.Select(m => m.SystemProperties[SystemProperties.MessageId]);
IEnumerable <string> receivedMessageIds = clientWatcher.ReceivedMessages.Select(m => m.MessageId);
Assert.Equal(expectedMessageIds, receivedMessageIds);
}