public async Task HandlesDirectMethodTopics(string topic)
{
var publishInfo = new MqttPublishInfo(topic, new byte[0]);
var(connectionRegistry, identityProvider) = GetHandlerDependencies();
var sut = new DirectMethodHandler(connectionRegistry, identityProvider);
var isHandled = await sut.HandleAsync(publishInfo);
Assert.True(isHandled);
}
public async Task CapturesDeviceIdentityFromResponseTopic()
{
var listenerCapture = new DeviceListenerCapture();
var publishInfo = new MqttPublishInfo("$edgehub/device_id/methods/res/200/?$rid=abcde", new byte[0]);
var(connectionRegistry, identityProvider) = GetHandlerDependencies(listenerCapture);
var sut = new DirectMethodHandler(connectionRegistry, identityProvider);
await sut.HandleAsync(publishInfo);
Assert.IsType <DeviceIdentity>(listenerCapture.Captured.Identity);
Assert.Equal("device_id", ((DeviceIdentity)listenerCapture.Captured.Identity).DeviceId);
}
public async Task SendsMessageDataAsPayload()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var(connectionRegistry, identityProvider) = GetHandlerDependencies();
var identity = new DeviceIdentity("hub", "device_id");
var method = new DirectMethodRequest("12345", "method", new byte[] { 1, 2, 3 }, TimeSpan.FromSeconds(5));
var sut = new DirectMethodHandler(connectionRegistry, identityProvider);
sut.SetConnector(connector);
await sut.CallDirectMethodAsync(method, identity, true);
Assert.Equal(new byte[] { 1, 2, 3 }, capture.Content);
}
public async Task EncodesDeviceNameInTopic()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var(connectionRegistry, identityProvider) = GetHandlerDependencies();
var identity = new DeviceIdentity("hub", "device_id");
var method = new DirectMethodRequest("12345", "method", new byte[] { 1, 2, 3 }, TimeSpan.FromSeconds(5));
var sut = new DirectMethodHandler(connectionRegistry, identityProvider);
sut.SetConnector(connector);
await sut.CallDirectMethodAsync(method, identity, true);
Assert.Equal("$edgehub/device_id/methods/post/method/?$rid=" + method.CorrelationId, capture.Topic);
}
public async Task AddsSystemPropertiesToMessage()
{
var listenerCapture = new DeviceListenerCapture();
var publishInfo = new MqttPublishInfo("$edgehub/device_id/module_id/methods/res/200/?$rid=abcde", new byte[0]);
var(connectionRegistry, identityProvider) = GetHandlerDependencies(listenerCapture);
var sut = new DirectMethodHandler(connectionRegistry, identityProvider);
await sut.HandleAsync(publishInfo);
var message = listenerCapture.Captured.CapturedMessage;
Assert.Contains(SystemProperties.CorrelationId, message.Properties);
Assert.Equal("abcde", message.Properties[SystemProperties.CorrelationId]);
Assert.Contains(SystemProperties.StatusCode, message.Properties);
Assert.Equal("200", message.Properties[SystemProperties.StatusCode]);
}
async Task <(IMessageConsumer, IMessageConsumer, NullBrokerConnector)> SetupEnvironment()
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
var defaultRetryStrategy = new FixedInterval(5, TimeSpan.FromSeconds(5));
var defaultRevivePeriod = TimeSpan.FromHours(1);
var defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorConfig = new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true);
var cloudProxyDispatcher = new BrokeredCloudProxyDispatcher();
var cloudConnectionProvider = new BrokeredCloudConnectionProvider(cloudProxyDispatcher);
var identityProvider = new IdentityProvider(iotHubName);
var deviceConnectivityManager = new BrokeredDeviceConnectivityManager(cloudProxyDispatcher);
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), new IdentityProvider(iotHubName), deviceConnectivityManager);
var routingMessageConverter = new RoutingMessageConverter();
var routeFactory = new EdgeRouteFactory(new EndpointFactory(connectionManager, routingMessageConverter, edgeDeviceId, 10, 10));
var routesList = new[] { routeFactory.Create("FROM /messages INTO $upstream") };
var endpoints = routesList.Select(r => r.Endpoint);
var routerConfig = new RouterConfig(endpoints, routesList);
var dbStoreProvider = new InMemoryDbStoreProvider();
var storeProvider = new StoreProvider(dbStoreProvider);
var messageStore = new MessageStore(storeProvider, CheckpointStore.Create(storeProvider), TimeSpan.MaxValue, false, 1800);
var endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(1, TimeSpan.FromMilliseconds(10)), messageStore);
var router = await Router.CreateAsync(Guid.NewGuid().ToString(), iotHubName, routerConfig, endpointExecutorFactory);
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var twinManager = TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>());
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
var edgeHub = new RoutingEdgeHub(router, routingMessageConverter, connectionManager, twinManager, edgeDeviceId, edgeModuleName, invokeMethodHandler, subscriptionProcessor, Mock.Of <IDeviceScopeIdentitiesCache>());
var brokerConnector = new NullBrokerConnector(cloudProxyDispatcher);
cloudProxyDispatcher.SetConnector(brokerConnector);
cloudProxyDispatcher.BindEdgeHub(edgeHub);
var connectionProvider = new ConnectionProvider(connectionManager, edgeHub, TimeSpan.FromSeconds(30));
var authenticator = new NullAuthenticator();
var edgeHubIdentity = new ModuleIdentity(iotHubName, edgeDeviceId, edgeModuleName);
var tokenCredentials = new TokenCredentials(edgeHubIdentity, "qwerty", "test-product", Option.Some("test-model"), Option.None <string>(), false);
var systemComponentProvider = new SystemComponentIdProvider(tokenCredentials);
var connectionHandler = default(ConnectionHandler);
connectionHandler = new ConnectionHandler(
Task.FromResult <IConnectionProvider>(connectionProvider),
Task.FromResult <IAuthenticator>(authenticator),
identityProvider,
systemComponentProvider,
DeviceProxyFactory);
DeviceProxy DeviceProxyFactory(IIdentity identity, bool isDirectClient)
{
return(new DeviceProxy(identity, isDirectClient, connectionHandler, Mock.Of <ITwinHandler>(), Mock.Of <IModuleToModuleMessageHandler>(), Mock.Of <ICloud2DeviceMessageHandler>(), Mock.Of <IDirectMethodHandler>()));
}
var cloud2DeviceMessageHandler = new Cloud2DeviceMessageHandler(connectionHandler);
var moduleToModuleMessageHandler = new ModuleToModuleMessageHandler(connectionHandler, identityProvider, new ModuleToModuleResponseTimeout(TimeSpan.FromSeconds(10)));
var directMethodHandler = new DirectMethodHandler(connectionHandler, identityProvider);
var twinHandler = new TwinHandler(connectionHandler, identityProvider);
var subscriptionChangeHandler = new SubscriptionChangeHandler(
cloud2DeviceMessageHandler,
moduleToModuleMessageHandler,
directMethodHandler,
twinHandler,
connectionHandler,
identityProvider);
return(subscriptionChangeHandler, cloudProxyDispatcher, brokerConnector);
}
