public async Task SmokeTest()
{
using (var sw = new StringWriter())
{
Console.SetOut(sw);
var console = new ConsoleEndpoint("id1");
IMessage[] messages = new [] { Message1 };
IProcessor processor = console.CreateProcessor();
await processor.ProcessAsync(new IMessage[0], CancellationToken.None);
await processor.ProcessAsync(messages, CancellationToken.None);
await processor.CloseAsync(CancellationToken.None);
string expectedWindows = $"(0) ConsoleEndpoint(id1): {Message1}\r\n";
string expectedLinux = $"(0) ConsoleEndpoint(id1): {Message1}\n";
Assert.True(expectedWindows.Equals(sw.ToString(), StringComparison.OrdinalIgnoreCase) ||
expectedLinux.Equals(sw.ToString(), StringComparison.OrdinalIgnoreCase));
Assert.Equal(console, processor.Endpoint);
Assert.True(processor.ErrorDetectionStrategy.IsTransient(new Exception()));
var console2 = new ConsoleEndpoint("id1", "name1", "hub1", ConsoleColor.Red);
Assert.Equal("id1", console2.Id);
Assert.Equal("name1", console2.Name);
Assert.Equal("hub1", console2.IotHubName);
}
}
public void CloudMessageProcessor_CloseAsyncTest()
{
Core.IMessageConverter <IRoutingMessage> routingMessageConverter = new RoutingMessageConverter();
var cloudProxy = Mock.Of <ICloudProxy>();
string cloudEndpointId = Guid.NewGuid().ToString();
var cloudEndpoint = new CloudEndpoint(cloudEndpointId, id => Task.FromResult(Option.Some(cloudProxy)), routingMessageConverter);
IProcessor moduleMessageProcessor = cloudEndpoint.CreateProcessor();
Task result = moduleMessageProcessor.CloseAsync(CancellationToken.None);
Assert.Equal(TaskEx.Done, result);
}
public void ModuleMessageProcessor_CloseAsyncTest()
{
Core.IMessageConverter <IRoutingMessage> routingMessageConverter = new RoutingMessageConverter();
var connectionManager = Mock.Of <IConnectionManager>();
string moduleId = "device1/module1";
string moduleEndpointAddress = "in1";
var moduleEndpoint = new ModuleEndpoint($"{moduleId}/{moduleEndpointAddress}", moduleId, moduleEndpointAddress, connectionManager, routingMessageConverter);
IProcessor moduleMessageProcessor = moduleEndpoint.CreateProcessor();
Task result = moduleMessageProcessor.CloseAsync(CancellationToken.None);
Assert.Equal(TaskEx.Done, result);
}
public async Task SmokeTest()
{
var endpoint = new RevivableEndpoint("id1");
IProcessor processor = endpoint.CreateProcessor();
Assert.True(processor.ErrorDetectionStrategy.IsTransient(new Exception()));
Assert.Equal(endpoint, processor.Endpoint);
Assert.Equal(new List <IMessage>(), endpoint.Processed);
Assert.Equal(string.Empty, endpoint.IotHubName);
ISinkResult <IMessage> result = await processor.ProcessAsync(new IMessage[0], CancellationToken.None);
Assert.Equal(new IMessage[0], result.Succeeded);
Assert.Equal(new List <IMessage>(), endpoint.Processed);
IMessage[] messages = new[] { Message1, Message2, Message3 };
ISinkResult <IMessage> result2 = await processor.ProcessAsync(messages, CancellationToken.None);
Assert.Equal(new[] { Message1, Message2, Message3 }, result2.Succeeded);
Assert.Equal(new List <IMessage> {
Message1, Message2, Message3
}, endpoint.Processed);
// set to failing
endpoint.Failing = true;
ISinkResult <IMessage> result3 = await processor.ProcessAsync(messages, CancellationToken.None);
Assert.True(result3.SendFailureDetails.HasValue);
Assert.Equal(new List <IMessage> {
Message1, Message2, Message3
}, endpoint.Processed);
// revive
endpoint.Failing = false;
ISinkResult <IMessage> result4 = await processor.ProcessAsync(messages, CancellationToken.None);
Assert.Equal(new[] { Message1, Message2, Message3 }, result4.Succeeded);
Assert.Equal(new List <IMessage> {
Message1, Message2, Message3, Message1, Message2, Message3
}, endpoint.Processed);
await processor.CloseAsync(CancellationToken.None);
}
public async Task SmokeTest()
{
var cts = new CancellationTokenSource();
var endpoint = new FailedEndpoint("id1", "name1", "hub1", new InvalidOperationException());
IProcessor processor = endpoint.CreateProcessor();
Assert.True(processor.ErrorDetectionStrategy.IsTransient(new Exception()));
Assert.Equal(endpoint, processor.Endpoint);
ISinkResult <IMessage> result = await processor.ProcessAsync(new IMessage[0], cts.Token);
Assert.True(result.SendFailureDetails.HasValue);
result.SendFailureDetails.ForEach(ex => Assert.IsType <InvalidOperationException>(ex.RawException));
Assert.True(processor.CloseAsync(CancellationToken.None).IsCompleted);
var endpoint2 = new FailedEndpoint("id2");
IProcessor processor2 = endpoint2.CreateProcessor();
ISinkResult <IMessage> result2 = await processor2.ProcessAsync(new IMessage[0], cts.Token);
Assert.True(result2.SendFailureDetails.HasValue);
result2.SendFailureDetails.ForEach(ex => Assert.IsType <Exception>(ex.RawException));
}
