public async Task EdgeHubChecksMessageSize()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of<IProcessor>();
var endpoint = new Mock<Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of<IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of<IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny<Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet<Endpoint> { endpoint.Object };
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
// Create mock for IConnectionManager
var connectionManager = Mock.Of<IConnectionManager>();
// Mock of twin manager
var twinManager = Mock.Of<ITwinManager>();
// Mock of identity
var identity = new Mock<IIdentity>();
identity.SetupGet(id => id.Id).Returns("something");
var messageConverter = new RoutingMessageConverter();
Message badMessage = new EdgeMessage.Builder(new byte[300 * 1024]).Build();
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager,
"testEdgeDevice",
Mock.Of<IInvokeMethodHandler>(),
Mock.Of<ISubscriptionProcessor>());
await Assert.ThrowsAsync<EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
string badString = Encoding.UTF8.GetString(new byte[300 * 1024], 0, 300 * 1024);
var badProperties = new Dictionary<string, string> { ["toolong"] = badString };
badMessage = new EdgeMessage.Builder(new byte[1]).SetProperties(badProperties).Build();
await Assert.ThrowsAsync<EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
badMessage = new Message(new byte[1], new Dictionary<string, string>(), badProperties);
await Assert.ThrowsAsync<EdgeHubMessageTooLargeException>(() => routingEdgeHub.ProcessDeviceMessage(identity.Object, badMessage));
}
public async Task SendMessageTest()
{
// Arrange
var feedbackStatus = FeedbackStatus.Abandon;
var deviceListener = new Mock <IDeviceListener>();
deviceListener.Setup(d => d.ProcessMessageFeedbackAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>()))
.Callback <string, FeedbackStatus>((m, s) => feedbackStatus = s)
.Returns(Task.CompletedTask);
AmqpMessage receivedAmqpMessage = null;
var connectionHandler = Mock.Of <IConnectionHandler>(c => c.GetDeviceListener() == Task.FromResult(deviceListener.Object));
var amqpAuthenticator = new Mock <IAmqpAuthenticator>();
amqpAuthenticator.Setup(c => c.AuthenticateAsync("d1")).ReturnsAsync(true);
Mock <ICbsNode> cbsNodeMock = amqpAuthenticator.As <ICbsNode>();
ICbsNode cbsNode = cbsNodeMock.Object;
var amqpConnection = Mock.Of <IAmqpConnection>(
c =>
c.FindExtension <IConnectionHandler>() == connectionHandler &&
c.FindExtension <ICbsNode>() == cbsNode);
var amqpSession = Mock.Of <IAmqpSession>(s => s.Connection == amqpConnection);
var sendingLink = Mock.Of <ISendingAmqpLink>(l => l.Session == amqpSession && !l.IsReceiver && l.Settings == new AmqpLinkSettings() && l.State == AmqpObjectState.Opened);
Mock.Get(sendingLink).Setup(s => s.SendMessageNoWait(It.IsAny <AmqpMessage>(), It.IsAny <ArraySegment <byte> >(), It.IsAny <ArraySegment <byte> >()))
.Callback <AmqpMessage, ArraySegment <byte>, ArraySegment <byte> >((m, d, t) => { receivedAmqpMessage = m; });
var requestUri = new Uri("amqps://foo.bar/devices/d1");
var boundVariables = new Dictionary <string, string> {
{ "deviceid", "d1" }
};
var messageConverter = new AmqpMessageConverter();
var identity = Mock.Of <IIdentity>(d => d.Id == "d1");
var metadataStore = Mock.Of <IMetadataStore>();
var sendingLinkHandler = new DeviceBoundLinkHandler(identity, sendingLink, requestUri, boundVariables, connectionHandler, messageConverter, metadataStore);
var body = new byte[] { 0, 1, 2, 3 };
IMessage message = new EdgeMessage.Builder(body).Build();
var deliveryState = new Mock <DeliveryState>(new AmqpSymbol(string.Empty), AmqpConstants.AcceptedOutcome.DescriptorCode);
var delivery = Mock.Of <Delivery>(
d => d.State == deliveryState.Object &&
d.DeliveryTag == new ArraySegment <byte>(Guid.NewGuid().ToByteArray()));
// Act
await sendingLinkHandler.OpenAsync(TimeSpan.FromSeconds(5));
await sendingLinkHandler.SendMessage(message);
// Assert
Assert.NotNull(receivedAmqpMessage);
Assert.Equal(body, receivedAmqpMessage.GetPayloadBytes());
// Act
sendingLinkHandler.DispositionListener(delivery);
await Task.Delay(TimeSpan.FromSeconds(5));
// Assert
Assert.Equal(FeedbackStatus.Complete, feedbackStatus);
}
public async Task AddEdgeSystemPropertiesTest()
{
// Create a mock endpoint capable of returning a mock processor
var endpoint = new Mock<Endpoint>("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of<IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of<IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny<Endpoint>())).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var endpoints = new HashSet<Endpoint> { endpoint.Object };
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoints);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var messageConverter = Mock.Of<Core.IMessageConverter<Devices.Routing.Core.IMessage>>();
// Create mock for IConnectionManager
var connectionManager = Mock.Of<IConnectionManager>();
// Mock of twin manager
var twinManager = Mock.Of<ITwinManager>();
string edgeDeviceId = "testEdgeDevice";
// Test Scenario
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager,
edgeDeviceId,
Mock.Of<IInvokeMethodHandler>(),
Mock.Of<ISubscriptionProcessor>());
Message clientMessage1 = new EdgeMessage.Builder(new byte[0]).Build();
clientMessage1.SystemProperties[SystemProperties.ConnectionDeviceId] = edgeDeviceId;
routingEdgeHub.AddEdgeSystemProperties(clientMessage1);
Assert.True(clientMessage1.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage1.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
Assert.Equal(Constants.InternalOriginInterface, clientMessage1.SystemProperties[SystemProperties.EdgeHubOriginInterface]);
Message clientMessage2 = new EdgeMessage.Builder(new byte[0]).Build();
clientMessage2.SystemProperties[SystemProperties.ConnectionDeviceId] = "downstreamDevice";
routingEdgeHub.AddEdgeSystemProperties(clientMessage2);
Assert.True(clientMessage2.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage2.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
Assert.Equal(Constants.DownstreamOriginInterface, clientMessage2.SystemProperties[SystemProperties.EdgeHubOriginInterface]);
Message clientMessage3 = new EdgeMessage.Builder(new byte[0]).Build();
routingEdgeHub.AddEdgeSystemProperties(clientMessage3);
Assert.False(clientMessage3.SystemProperties.ContainsKey(SystemProperties.EdgeHubOriginInterface));
Assert.True(clientMessage3.SystemProperties.ContainsKey(SystemProperties.EdgeMessageId));
}
Task <bool> HandleUpdateReported(Match match, MqttPublishInfo publishInfo)
{
return(this.HandleUpstreamRequest(
async(listener, rid) =>
{
var message = new EdgeMessage.Builder(publishInfo.Payload).Build();
await listener.UpdateReportedPropertiesAsync(message, rid);
},
match,
publishInfo));
}
void HandleDesiredProperyUpdate(string id, string version, byte[] payload)
{
var messageBuilder = new EdgeMessage.Builder(payload);
messageBuilder.SetSystemProperties(
new Dictionary <string, string>()
{
[SystemProperties.Version] = version
});
_ = this.edgeHub.UpdateDesiredPropertiesAsync(id, messageBuilder.Build());
}
public async Task SendMessageWithFeedbackExactlyOnceModeTest()
{
// Arrange
var feedbackStatus = FeedbackStatus.Abandon;
var deviceListener = new Mock <IDeviceListener>();
deviceListener.Setup(d => d.ProcessMessageFeedbackAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>()))
.Callback <string, FeedbackStatus>((m, s) => feedbackStatus = s)
.Returns(Task.CompletedTask);
AmqpMessage receivedAmqpMessage = null;
var connectionHandler = Mock.Of <IConnectionHandler>(c => c.GetDeviceListener() == Task.FromResult(deviceListener.Object) &&
c.GetAmqpAuthentication() == Task.FromResult(new AmqpAuthentication(true, Option.Some(Mock.Of <IClientCredentials>()))));
var amqpConnection = Mock.Of <IAmqpConnection>(c => c.FindExtension <IConnectionHandler>() == connectionHandler);
var amqpSession = Mock.Of <IAmqpSession>(s => s.Connection == amqpConnection);
var amqpLinkSettings = new AmqpLinkSettings();
var sendingLink = Mock.Of <ISendingAmqpLink>(l => l.Session == amqpSession && !l.IsReceiver && l.Settings == amqpLinkSettings && l.State == AmqpObjectState.Opened);
Mock.Get(sendingLink).Setup(s => s.SendMessageNoWait(It.IsAny <AmqpMessage>(), It.IsAny <ArraySegment <byte> >(), It.IsAny <ArraySegment <byte> >()))
.Callback <AmqpMessage, ArraySegment <byte>, ArraySegment <byte> >((m, d, t) => { receivedAmqpMessage = m; });
var requestUri = new Uri("amqps://foo.bar/devices/d1");
var boundVariables = new Dictionary <string, string> {
{ "deviceid", "d1" }
};
var messageConverter = new AmqpMessageConverter();
var sendingLinkHandler = new TestSendingLinkHandler(sendingLink, requestUri, boundVariables, messageConverter, QualityOfService.ExactlyOnce);
var body = new byte[] { 0, 1, 2, 3 };
IMessage message = new EdgeMessage.Builder(body).Build();
var deliveryState = new Mock <DeliveryState>(new AmqpSymbol(""), AmqpConstants.AcceptedOutcome.DescriptorCode);
var delivery = Mock.Of <Delivery>(d => d.State == deliveryState.Object &&
d.DeliveryTag == new ArraySegment <byte>(Guid.NewGuid().ToByteArray()));
// Act
await sendingLinkHandler.OpenAsync(TimeSpan.FromSeconds(5));
await sendingLinkHandler.SendMessage(message);
// Assert
Assert.NotNull(receivedAmqpMessage);
Assert.Equal(body, receivedAmqpMessage.GetPayloadBytes());
// Act
sendingLinkHandler.DispositionListener(delivery);
await Task.Delay(TimeSpan.FromSeconds(5));
// Assert
Assert.Equal(feedbackStatus, FeedbackStatus.Complete);
Assert.Equal(null, amqpLinkSettings.SndSettleMode);
Assert.Equal((byte)ReceiverSettleMode.Second, amqpLinkSettings.RcvSettleMode);
}
public async Task UpdateDesiredPropertiesForwardsToTwinManager()
{
// Create a mock endpoint capable of returning a mock processor
var processor = Mock.Of <IProcessor>();
var endpoint = new Mock <Endpoint>("myId");
endpoint.Setup(ep => ep.CreateProcessor()).Returns(processor);
endpoint.SetupGet(ep => ep.Id).Returns("myId");
// Create a mock endpoint executor factory to create the endpoint executor to verify invocation
var endpointExecutor = Mock.Of <IEndpointExecutor>();
Mock.Get(endpointExecutor).SetupGet(ee => ee.Endpoint).Returns(() => endpoint.Object);
var endpointExecutorFactory = Mock.Of <IEndpointExecutorFactory>();
Mock.Get(endpointExecutorFactory).Setup(eef => eef.CreateAsync(It.IsAny <Endpoint>(), new List <uint>()
{
0
})).ReturnsAsync(endpointExecutor);
// Create a route to map to the message
var route = new Route("myRoute", "true", "myIotHub", TelemetryMessageSource.Instance, endpoint.Object, 0, 3600);
// Create a router
var routerConfig = new RouterConfig(new[] { route });
Router router = await Router.CreateAsync("myRouter", "myIotHub", routerConfig, endpointExecutorFactory);
var messageConverter = Mock.Of <Core.IMessageConverter <Devices.Routing.Core.IMessage> >();
var connectionManager = Mock.Of <IConnectionManager>();
var twinManager = new Mock <ITwinManager>();
var message = Mock.Of <IMessage>();
IMessage received = new EdgeMessage.Builder(new byte[0]).Build();
twinManager.Setup(t => t.UpdateDesiredPropertiesAsync(It.IsAny <string>(), It.IsAny <IMessage>())).Callback <string, IMessage>((s, m) => received = message).Returns(Task.CompletedTask);
var routingEdgeHub = new RoutingEdgeHub(
router,
messageConverter,
connectionManager,
twinManager.Object,
"testEdgeDevice",
"$edgeHub",
Mock.Of <IInvokeMethodHandler>(),
Mock.Of <ISubscriptionProcessor>(),
Mock.Of <IDeviceScopeIdentitiesCache>());
await routingEdgeHub.UpdateDesiredPropertiesAsync("*", message);
twinManager.Verify(x => x.UpdateDesiredPropertiesAsync("*", message), Times.Once);
Assert.Equal(message, received);
}
public void ConvertsTwinMessagesToMqttMessages(Twin twin, string expectedJson)
{
EdgeMessage expectedMessage = new EdgeMessage.Builder(expectedJson.ToBody())
.SetSystemProperties(new Dictionary <string, string>()
{
[SystemProperties.EnqueuedTime] = ""
})
.Build();
IMessage actualMessage = new TwinMessageConverter().ToMessage(twin);
Assert.Equal(expectedMessage.Body, actualMessage.Body);
Assert.Equal(expectedMessage.Properties, actualMessage.Properties);
Assert.Equal(expectedMessage.SystemProperties.Keys, actualMessage.SystemProperties.Keys);
}
public async Task SendMessageWithNoFeedbackTest()
{
// Arrange
var productInfoStore = Mock.Of <IProductInfoStore>();
var modelIdStore = Mock.Of <IModelIdStore>();
var identity = Mock.Of <IIdentity>(i => i.Id == "d1");
var deviceListener = new Mock <IDeviceListener>();
deviceListener.Setup(d => d.ProcessMessageFeedbackAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>()))
.Returns(Task.CompletedTask);
AmqpMessage receivedAmqpMessage = null;
var connectionHandler = Mock.Of <IConnectionHandler>(c => c.GetDeviceListener() == Task.FromResult(deviceListener.Object));
var amqpAuthenticator = new Mock <IAmqpAuthenticator>();
amqpAuthenticator.Setup(c => c.AuthenticateAsync("d1")).ReturnsAsync(true);
Mock <ICbsNode> cbsNodeMock = amqpAuthenticator.As <ICbsNode>();
ICbsNode cbsNode = cbsNodeMock.Object;
var amqpConnection = Mock.Of <IAmqpConnection>(
c =>
c.FindExtension <IConnectionHandler>() == connectionHandler &&
c.FindExtension <ICbsNode>() == cbsNode);
var amqpSession = Mock.Of <IAmqpSession>(s => s.Connection == amqpConnection);
var amqpLinkSettings = new AmqpLinkSettings();
var sendingLink = Mock.Of <ISendingAmqpLink>(l => l.Session == amqpSession && !l.IsReceiver && l.Settings == amqpLinkSettings && l.State == AmqpObjectState.Opened);
Mock.Get(sendingLink).Setup(s => s.SendMessageAsync(It.IsAny <AmqpMessage>(), It.IsAny <ArraySegment <byte> >(), It.IsAny <ArraySegment <byte> >(), It.IsAny <TimeSpan>()))
.Callback <AmqpMessage, ArraySegment <byte>, ArraySegment <byte>, TimeSpan>((m, d, t, ts) => { receivedAmqpMessage = m; })
.Returns(Task.CompletedTask);
var requestUri = new Uri("amqps://foo.bar/devices/d1");
var boundVariables = new Dictionary <string, string> {
{ "deviceid", "d1" }
};
var messageConverter = new AmqpMessageConverter();
var sendingLinkHandler = new TestSendingLinkHandler(identity, sendingLink, requestUri, boundVariables, connectionHandler, messageConverter, QualityOfService.AtMostOnce, productInfoStore, modelIdStore);
var body = new byte[] { 0, 1, 2, 3 };
IMessage message = new EdgeMessage.Builder(body).Build();
// Act
await sendingLinkHandler.OpenAsync(TimeSpan.FromSeconds(5));
await sendingLinkHandler.SendMessage(message);
// Assert
Assert.NotNull(receivedAmqpMessage);
Assert.Equal(body, receivedAmqpMessage.GetPayloadBytes());
Assert.Equal((byte)SenderSettleMode.Settled, amqpLinkSettings.SndSettleMode);
Assert.Equal((byte)ReceiverSettleMode.First, amqpLinkSettings.RcvSettleMode);
}
public async Task UpdateReportedPropertiesAsync(IMessage reportedPropertiesMessage, string correlationId)
{
reportedPropertiesMessage.SystemProperties[SystemProperties.EnqueuedTime] = DateTime.UtcNow.ToString("o");
reportedPropertiesMessage.SystemProperties[SystemProperties.MessageSchema] = Constants.TwinChangeNotificationMessageSchema;
reportedPropertiesMessage.SystemProperties[SystemProperties.MessageType] = Constants.TwinChangeNotificationMessageType;
switch (this.Identity)
{
case IModuleIdentity moduleIdentity:
reportedPropertiesMessage.SystemProperties[SystemProperties.RpConnectionDeviceIdInternal] = moduleIdentity.DeviceId;
reportedPropertiesMessage.SystemProperties[SystemProperties.RpConnectionModuleIdInternal] = moduleIdentity.ModuleId;
break;
case IDeviceIdentity deviceIdentity:
reportedPropertiesMessage.SystemProperties[SystemProperties.RpConnectionDeviceIdInternal] = deviceIdentity.DeviceId;
break;
}
reportedPropertiesMessage.SystemProperties[SystemProperties.ConnectionDeviceId] = this.edgeHub.GetEdgeDeviceId();
reportedPropertiesMessage.SystemProperties[SystemProperties.ConnectionModuleId] = Constants.EdgeHubModuleId;
try
{
using (Metrics.TimeReportedPropertiesUpdate(this.Identity.Id))
{
await this.edgeHub.UpdateReportedPropertiesAsync(this.Identity, reportedPropertiesMessage);
Metrics.AddUpdateReportedProperties(this.Identity.Id);
if (!string.IsNullOrWhiteSpace(correlationId))
{
IMessage responseMessage = new EdgeMessage.Builder(new byte[0])
.SetSystemProperties(
new Dictionary <string, string>
{
[SystemProperties.CorrelationId] = correlationId,
[SystemProperties.EnqueuedTime] = DateTime.UtcNow.ToString("o"),
[SystemProperties.StatusCode] = ((int)HttpStatusCode.NoContent).ToString()
})
.Build();
await this.SendTwinUpdate(responseMessage);
}
}
}
catch (Exception e)
{
Events.ErrorUpdatingReportedPropertiesTwin(this.Identity, e);
await this.HandleTwinOperationException(correlationId, e);
}
}
public async Task OnDesiredPropertyUpdatesForwardsToEdgeHub()
{
var edgeHub = new Mock <IEdgeHub>();
var identity = Mock.Of <IIdentity>(i => i.Id == "device1");
IMessage actual = null;
edgeHub.Setup(r => r.UpdateDesiredPropertiesAsync(It.IsAny <string>(), It.IsAny <IMessage>()))
.Callback <string, IMessage>((s, m) => actual = m)
.Returns(Task.FromResult(true));
IMessage expected = new EdgeMessage.Builder(Encoding.UTF8.GetBytes("{\"abc\":\"xyz\"}")).Build();
var cloudListener = new CloudListener(edgeHub.Object, identity.Id);
await cloudListener.OnDesiredPropertyUpdates(expected);
Assert.Equal(expected, actual);
}
public async Task RemoveDesiredPropertyUpdatesSubscription(string correlationId)
{
await this.edgeHub.RemoveSubscription(this.Identity.Id, DeviceSubscription.DesiredPropertyUpdates);
if (!string.IsNullOrWhiteSpace(correlationId))
{
IMessage responseMessage = new EdgeMessage.Builder(new byte[0])
.SetSystemProperties(new Dictionary <string, string>
{
[SystemProperties.CorrelationId] = correlationId,
[SystemProperties.StatusCode] = ((int)HttpStatusCode.OK).ToString()
})
.Build();
await this.SendTwinUpdate(responseMessage);
}
}
public async Task InvokedMethodMismatchedResponseTest()
{
DeviceMessageHandler deviceMessageHandler = this.GetDeviceMessageHandler();
var methodRequest = new DirectMethodRequest("device10", "shutdown", null, TimeSpan.FromSeconds(2), TimeSpan.FromMilliseconds(10));
Task <DirectMethodResponse> responseTask = deviceMessageHandler.InvokeMethodAsync(methodRequest);
Assert.False(responseTask.IsCompleted);
IMessage message = new EdgeMessage.Builder(new byte[0]).Build();
message.Properties[SystemProperties.CorrelationId] = methodRequest.CorrelationId + 1;
message.Properties[SystemProperties.StatusCode] = "200";
await deviceMessageHandler.ProcessMethodResponseAsync(message);
Assert.False(responseTask.IsCompleted);
}
public async Task DesiredUpdateRequiresVersion()
{
var(connectionRegistry, identityProvider) = GetHandlerDependencies();
var connector = GetConnector();
var identity = new DeviceIdentity("hub", "device_id");
var twin = new EdgeMessage.Builder(new byte[] { 1, 2, 3 }).Build();
var sut = new TwinHandler(connectionRegistry, identityProvider);
sut.SetConnector(connector);
await sut.SendDesiredPropertiesUpdate(twin, identity, true);
Mock.Get(connector)
.Verify(c => c.SendAsync(It.IsAny <string>(), It.IsAny <byte[]>()), Times.Never());
}
public void ConvertsTwinCollectionsToMqttMessages(TwinCollection collection, string expectedJson)
{
EdgeMessage expectedMessage = new EdgeMessage.Builder(expectedJson.ToBody())
.SetSystemProperties(
new Dictionary <string, string>()
{
[SystemProperties.EnqueuedTime] = string.Empty,
[SystemProperties.Version] = collection.Version.ToString()
})
.Build();
IMessage actualMessage = new TwinCollectionMessageConverter().ToMessage(collection);
Assert.Equal(expectedMessage.Body, actualMessage.Body);
Assert.Equal(expectedMessage.Properties, actualMessage.Properties);
Assert.Equal(expectedMessage.SystemProperties.Keys, actualMessage.SystemProperties.Keys);
Assert.Equal(expectedMessage.SystemProperties[SystemProperties.Version], actualMessage.SystemProperties[SystemProperties.Version]);
}
public IMessage ToMessage(IProtocolGatewayMessage sourceMessage)
{
if (!this.addressConvertor.TryParseProtocolMessagePropsFromAddress(sourceMessage))
{
throw new InvalidOperationException("Topic name could not be matched against any of the configured routes.");
}
byte[] payloadBytes = this.byteBufferConverter.ToByteArray(sourceMessage.Payload);
// TODO - What about the other properties (like sequence number, etc)? Ignoring for now, as they are not used anyways.
var systemProperties = new Dictionary <string, string>();
var properties = new Dictionary <string, string>();
if (sourceMessage.Properties.TryGetValue(TemplateParameters.DeviceIdTemplateParam, out string deviceIdValue))
{
systemProperties[SystemProperties.ConnectionDeviceId] = deviceIdValue;
sourceMessage.Properties.Remove(TemplateParameters.DeviceIdTemplateParam);
}
if (sourceMessage.Properties.TryGetValue(Constants.ModuleIdTemplateParameter, out string moduleIdValue))
{
systemProperties[SystemProperties.ConnectionModuleId] = moduleIdValue;
sourceMessage.Properties.Remove(Constants.ModuleIdTemplateParameter);
}
foreach (KeyValuePair <string, string> property in sourceMessage.Properties)
{
if (SystemProperties.IncomingSystemPropertiesMap.TryGetValue(property.Key, out string systemPropertyName))
{
systemProperties.Add(systemPropertyName, property.Value);
}
else
{
properties.Add(property.Key, property.Value);
}
}
EdgeMessage hubMessage = new EdgeMessage.Builder(payloadBytes)
.SetProperties(properties)
.SetSystemProperties(systemProperties)
.Build();
return(hubMessage);
}
public async Task DoesNotSendToDevice()
{
var connector = GetConnector();
var connectionRegistry = GetConnectionRegistry();
var identity = new DeviceIdentity("hub", "device_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.Build();
var sut = new ModuleToModuleMessageHandler(connectionRegistry);
sut.SetConnector(connector);
await sut.SendModuleToModuleMessageAsync(message, "some_input", identity);
Mock.Get(connector)
.Verify(c => c.SendAsync(It.IsAny <string>(), It.IsAny <byte[]>()), Times.Never());
}
public async Task SendsMessageDataAsPayload()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var connectionRegistry = GetConnectionRegistry();
var identity = new ModuleIdentity("hub", "device_id", "module_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.Build();
var sut = new ModuleToModuleMessageHandler(connectionRegistry);
sut.SetConnector(connector);
await sut.SendModuleToModuleMessageAsync(message, "some_input", identity);
Assert.Equal(new byte[] { 0x01, 0x02, 0x03 }, capture.Content);
}
public async Task EncodesModuleNameInTopic()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var connectionRegistry = GetConnectionRegistry();
var identity = new ModuleIdentity("hub", "device_id", "module_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.Build();
var sut = new ModuleToModuleMessageHandler(connectionRegistry);
sut.SetConnector(connector);
await sut.SendModuleToModuleMessageAsync(message, "some_input", identity);
Assert.Equal("$edgehub/device_id/module_id/inputs/some_input/", capture.Topic);
}
public async Task EncodesDeviceNameInTopic()
{
var capture = new SendCapture();
var connector = GetConnector(capture);
var connectionRegistry = GetConnectionRegistry();
var identity = new DeviceIdentity("hub", "device_id");
var message = new EdgeMessage
.Builder(new byte[] { 0x01, 0x02, 0x03 })
.Build();
var sut = new Cloud2DeviceMessageHandler(connectionRegistry);
sut.SetConnector(connector);
await sut.SendC2DMessageAsync(message, identity);
Assert.Equal("$edgehub/device_id/messages/c2d/post/", capture.Topic);
}
public async Task TestProcessMessage()
{
var edgeHub = new Mock <IEdgeHub>();
var identity = Mock.Of <IIdentity>(i => i.Id == "device1");
IMessage sentMessage = null;
edgeHub.Setup(r => r.SendC2DMessageAsync(It.IsAny <string>(), It.IsAny <IMessage>()))
.Returns(Task.FromResult(true))
.Callback <string, IMessage>((id, m) => sentMessage = m);
var cloudListener = new CloudListener(edgeHub.Object, identity.Id);
var payload = new byte[] { 1, 2, 3 };
IMessage message = new EdgeMessage.Builder(payload).Build();
await cloudListener.ProcessMessageAsync(message);
Assert.NotNull(sentMessage);
}
async Task HandleTwinOperationException(string correlationId, Exception e)
{
if (!string.IsNullOrWhiteSpace(correlationId))
{
int statusCode = e is InvalidOperationException || e is ArgumentException
? (int)HttpStatusCode.BadRequest
: (int)HttpStatusCode.InternalServerError;
IMessage responseMessage = new EdgeMessage.Builder(new byte[0])
.SetSystemProperties(new Dictionary <string, string>
{
[SystemProperties.CorrelationId] = correlationId,
[SystemProperties.EnqueuedTime] = DateTime.UtcNow.ToString("o"),
[SystemProperties.StatusCode] = statusCode.ToString()
})
.Build();
await this.SendTwinUpdate(responseMessage);
}
}
public async Task DesiredUpdateCallForwarded()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var desired = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(twinHandler)
.Setup(h => h.SendDesiredPropertiesUpdate(It.Is <IMessage>(m => m == desired), It.Is <IIdentity>(i => i == identity)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.OnDesiredPropertyUpdates(desired);
Mock.Get(directMethodHandler).VerifyAll();
}
public async Task Cloud2DeviceMessagesForwarded()
{
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var message = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(c2dHandler)
.Setup(h => h.SendC2DMessageAsync(It.Is <IMessage>(m => m == message), It.Is <IIdentity>(i => i == identity)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.SendC2DMessageAsync(message);
Mock.Get(directMethodHandler).VerifyAll();
}
public async Task MultipleMessageCompletionTest()
{
var connMgr = new Mock <IConnectionManager>();
connMgr.Setup(c => c.AddDeviceConnection(It.IsAny <IIdentity>(), It.IsAny <IDeviceProxy>()));
var identity = Mock.Of <IModuleIdentity>(m => m.DeviceId == "device1" && m.ModuleId == "module1" && m.Id == "device1/module1");
var cloudProxy = new Mock <ICloudProxy>();
cloudProxy.Setup(c => c.SendFeedbackMessageAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>()))
.Returns(Task.CompletedTask);
var edgeHub = Mock.Of <IEdgeHub>();
var underlyingDeviceProxy = new Mock <IDeviceProxy>();
IMessage receivedMessage = null;
underlyingDeviceProxy.Setup(d => d.SendMessageAsync(It.IsAny <IMessage>(), It.IsAny <string>()))
.Callback <IMessage, string>((m, s) => receivedMessage = m)
.Returns(Task.CompletedTask);
connMgr.Setup(c => c.GetCloudConnection(It.IsAny <string>())).Returns(Task.FromResult(Option.Some(cloudProxy.Object)));
var deviceMessageHandler = new DeviceMessageHandler(identity, edgeHub, connMgr.Object, DefaultMessageAckTimeout, Option.None <string>());
deviceMessageHandler.BindDeviceProxy(underlyingDeviceProxy.Object);
IMessage message = new EdgeMessage.Builder(new byte[0]).Build();
Task sendMessageTask = deviceMessageHandler.SendMessageAsync(message, "input1");
Assert.False(sendMessageTask.IsCompleted);
string messageId = receivedMessage.SystemProperties[SystemProperties.LockToken];
await deviceMessageHandler.ProcessMessageFeedbackAsync(messageId, FeedbackStatus.Complete);
await Task.Delay(TimeSpan.FromSeconds(1));
Assert.True(sendMessageTask.IsCompleted);
await deviceMessageHandler.ProcessMessageFeedbackAsync(messageId, FeedbackStatus.Complete);
await Task.Delay(TimeSpan.FromSeconds(1));
Assert.True(sendMessageTask.IsCompleted);
cloudProxy.Verify(c => c.SendFeedbackMessageAsync(It.IsAny <string>(), It.IsAny <FeedbackStatus>()), Times.Never);
}
public async Task EdgeHubIsIndirect()
{
var connectionHandler = Mock.Of <IConnectionRegistry>();
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new ModuleIdentity("hub", "device_id", "$edgeHub");
var twin = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(twinHandler)
.Setup(h => h.SendTwinUpdate(It.IsAny <IMessage>(), It.Is <IIdentity>(i => i == identity), It.Is <bool>(d => d == false)))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, true, connectionHandler, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.SendTwinUpdate(twin);
Mock.Get(twinHandler).VerifyAll();
}
public async Task TestHandleNonRecoverableExceptions(Type exceptionType)
{
// Arrange
var messageConverter = Mock.Of <IMessageConverter <Message> >(m => m.FromMessage(It.IsAny <IMessage>()) == new Message());
var messageConverterProvider = Mock.Of <IMessageConverterProvider>(m => m.Get <Message>() == messageConverter);
string clientId = "d1";
var cloudListener = Mock.Of <ICloudListener>();
TimeSpan idleTimeout = TimeSpan.FromSeconds(60);
Action <string, CloudConnectionStatus> connectionStatusChangedHandler = (s, status) => { };
var client = new Mock <IClient>(MockBehavior.Strict);
client.Setup(c => c.SendEventAsync(It.IsAny <Message>())).ThrowsAsync((Exception)Activator.CreateInstance(exceptionType, "dummy message"));
client.Setup(c => c.CloseAsync()).Returns(Task.CompletedTask);
var cloudProxy = new CloudProxy(client.Object, messageConverterProvider, clientId, connectionStatusChangedHandler, cloudListener, idleTimeout, false);
IMessage message = new EdgeMessage.Builder(new byte[0]).Build();
// Act
await Assert.ThrowsAsync(exceptionType, () => cloudProxy.SendMessageAsync(message));
// Assert.
client.VerifyAll();
}
public IMessage ToMessage(AmqpMessage amqpMessage)
{
var properties = new Dictionary <string, string>();
if (amqpMessage.Properties.CorrelationId != null)
{
properties[SystemProperties.CorrelationId] = amqpMessage.Properties.CorrelationId.ToString();
}
if (amqpMessage.ApplicationProperties.Map.TryGetValue(Constants.MessagePropertiesStatusKey, out int status))
{
properties[SystemProperties.StatusCode] = status.ToString();
}
byte[] payload = amqpMessage.GetPayloadBytes();
EdgeMessage message = new EdgeMessage.Builder(payload)
.SetProperties(properties)
.Build();
return(message);
}
public async Task Moudle2MoudleMessagesForwarded()
{
var connectionHandler = Mock.Of <IConnectionRegistry>();
var twinHandler = Mock.Of <ITwinHandler>();
var m2mHandler = Mock.Of <IModuleToModuleMessageHandler>();
var c2dHandler = Mock.Of <ICloud2DeviceMessageHandler>();
var directMethodHandler = Mock.Of <IDirectMethodHandler>();
var identity = new DeviceIdentity("hub", "device_id");
var input = "input";
var message = new EdgeMessage.Builder(new byte[0]).Build();
Mock.Get(m2mHandler)
.Setup(h => h.SendModuleToModuleMessageAsync(It.Is <IMessage>(m => m == message), It.Is <string>(s => s == input), It.Is <IIdentity>(i => i == identity), It.IsAny <bool>()))
.Returns(Task.CompletedTask);
var sut = new DeviceProxy(identity, true, connectionHandler, twinHandler, m2mHandler, c2dHandler, directMethodHandler);
await sut.SendMessageAsync(message, input);
Mock.Get(m2mHandler).VerifyAll();
}
public async Task <DirectMethodResponse> InvokeMethodAsync(DirectMethodRequest request)
{
if (!this.connectionHandler.registry.TryGetValue(LinkType.MethodSending, out ILinkHandler linkHandler))
{
Events.LinkNotFound(LinkType.ModuleMessages, this.Identity, "method request");
return(default(DirectMethodResponse));
}
IMessage message = new EdgeMessage.Builder(request.Data)
.SetProperties(new Dictionary <string, string>
{
[Constants.MessagePropertiesMethodNameKey] = request.Name
})
.SetSystemProperties(new Dictionary <string, string>
{
[SystemProperties.CorrelationId] = request.CorrelationId
})
.Build();
await((ISendingLinkHandler)linkHandler).SendMessage(message);
return(default(DirectMethodResponse));
}
