public async Task RoundtripTest()
{
// Arrange
var underlyingCredentialsCache = new NullCredentialsCache();
var credentialsCache = new CredentialsCache(underlyingCredentialsCache);
var identity1 = Mock.Of <IIdentity>(i => i.Id == "d1");
var identity2 = Mock.Of <IIdentity>(i => i.Id == "d2/m2");
var creds1 = Mock.Of <ITokenCredentials>(c => c.Identity == identity1);
var creds2 = Mock.Of <IClientCredentials>(c => c.Identity == identity2);
// Act
await credentialsCache.Add(creds1);
await credentialsCache.Add(creds2);
Option <IClientCredentials> receivedClientCredentials1 = await credentialsCache.Get(identity1);
Option <IClientCredentials> receivedClientCredentials2 = await credentialsCache.Get(identity2);
// Assert
Assert.True(receivedClientCredentials1.HasValue);
Assert.True(receivedClientCredentials2.HasValue);
Assert.Equal(creds1, receivedClientCredentials1.OrDefault());
Assert.Equal(creds2, receivedClientCredentials2.OrDefault());
}
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);
}
internal Credentials GetCredentials(Uri uri, bool cacheAllowed, bool hidePasswordField)
{
// Synchronized access to the GetCredentials() method prevents multiple login dialogs when loading multiple files at once
// (e.g. on startup). So the user only needs to enter credentials once for the same host.
lock (this)
{
string userName = null;
string password = null;
if (uri.UserInfo != null && uri.UserInfo.Length > 0)
{
string[] split = uri.UserInfo.Split(new char[] { ':' });
if (split.Length > 0)
{
userName = split[0];
}
if (split.Length > 1)
{
password = split[1];
}
}
IList <string> usersForHost = CredentialsCache.GetUsersForHost(uri.Host);
if (userName == null && cacheAllowed)
{
if (usersForHost.Count == 1)
{
userName = usersForHost[0];
}
}
if (userName != null && password == null && cacheAllowed)
{
Credentials cred = CredentialsCache.GetCredentials(uri.Host, userName);
if (cred != null)
{
return(cred);
}
}
if (userName == null || password == null)
{
LoginDialog dlg = new LoginDialog(uri.Host, usersForHost, hidePasswordField);
dlg.UserName = userName;
if (DialogResult.OK == dlg.ShowDialog())
{
password = dlg.Password;
userName = dlg.UserName;
}
dlg.Dispose();
}
Credentials credentials = new Credentials(uri.Host, userName, password);
CredentialsCache.Add(credentials);
return(credentials);
}
}
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, 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);
}
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 = new CredentialsCache(new NullCredentialsCache());
IConnectionManager connectionManager = new ConnectionManager(cloudConnectionProvider, credentialsCache);
IClientCredentials clientCredentials1 = GetClientCredentials(TimeSpan.FromSeconds(10));
await credentialsCache.Add(clientCredentials1);
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));
await credentialsCache.Add(clientCredentials2);
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));
await credentialsCache.Add(clientCredentials3);
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);
}