public void ServerTransportCanSendMessages()
{
var logger = XUnitLogger.CreateLogger(_testOutput);
using (var connection = new TestWebSocketConnectionFeature())
{
var server = connection.AcceptAsync().GetAwaiter().GetResult();
var client = connection.Client;
var receiverRunning = ReceiveAsync(client);
var fromTransport = new Pipe(PipeOptions.Default);
var toTransport = new Pipe(PipeOptions.Default);
var webSocketManager = new Mock <WebSocketManager>();
webSocketManager.Setup(m => m.AcceptWebSocketAsync()).Returns(Task.FromResult(server));
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.WebSockets).Returns(webSocketManager.Object);
var sut = new WebSocketTransport(httpContext.Object.WebSockets.AcceptWebSocketAsync().GetAwaiter().GetResult(), new DuplexPipe(toTransport.Reader, fromTransport.Writer), logger);
var serverTransportRunning = sut.ConnectAsync(CancellationToken.None);
var messages = new List <byte[]> {
Encoding.UTF8.GetBytes("foo")
};
WriteAsync(toTransport.Writer, messages).Wait();
toTransport.Writer.CompleteAsync().GetAwaiter().GetResult();
serverTransportRunning.Wait();
var output = receiverRunning.GetAwaiter().GetResult();
Assert.Equal("foo", Encoding.UTF8.GetString(output[0]));
}
}
public async Task ServerTransportCanReceiveMessages()
{
var logger = XUnitLogger.CreateLogger(_testOutput);
using (var connection = new TestWebSocketConnectionFeature())
{
var server = connection.AcceptAsync();
var client = connection.Client;
var fromTransport = new Pipe(PipeOptions.Default);
var toTransport = new Pipe(PipeOptions.Default);
var listenerRunning = ListenAsync(fromTransport.Reader);
var webSocketManager = new Mock <WebSocketManager>();
webSocketManager.Setup(m => m.AcceptWebSocketAsync()).Returns(server);
var httpContext = new Mock <HttpContext>();
httpContext.Setup(c => c.WebSockets).Returns(webSocketManager.Object);
var sut = new WebSocketTransport(httpContext.Object.WebSockets.AcceptWebSocketAsync().GetAwaiter().GetResult(), new DuplexPipe(toTransport.Reader, fromTransport.Writer), logger);
var serverTransportRunning = sut.ConnectAsync(CancellationToken.None);
var messages = new List <byte[]> {
Encoding.UTF8.GetBytes("foo"), Encoding.UTF8.GetBytes("bar")
};
SendBinaryAsync(client, messages).Wait();
client.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done sending.", CancellationToken.None).Wait();
serverTransportRunning.Wait();
var output = await listenerRunning;
Assert.Equal("foo", Encoding.UTF8.GetString(output[0]));
Assert.Equal("bar", Encoding.UTF8.GetString(output[1]));
}
}
public void NamedPipeActivityTest()
{
const string pipeName = "test.pipe";
var logger = XUnitLogger.CreateLogger(_testOutput);
// Arrange
var activity = new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "unknown",
ChannelId = "test",
Text = "hi"
};
var bot = new StreamingTestBot((turnContext, cancellationToken) =>
{
var activityClone = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(turnContext.Activity));
activityClone.Text = $"Echo: {turnContext.Activity.Text}";
return(turnContext.SendActivityAsync(activityClone, cancellationToken));
});
var verifiedResponse = false;
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>()))
.Returns <ReceiveRequest, ILogger <RequestHandler>, object, CancellationToken>((request, anonLogger, context, cancellationToken) =>
{
var body = request.ReadBodyAsString();
var response = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings);
Assert.NotNull(response);
Assert.Equal("Echo: hi", response.Text);
verifiedResponse = true;
return(Task.FromResult(StreamingResponse.OK()));
});
// Act
var server = new CloudAdapter(new StreamingTestBotFrameworkAuthentication(), logger);
var serverRunning = server.ConnectNamedPipeAsync(pipeName, bot, "testAppId", "testAudience", "testCallerId");
var client = new NamedPipeClient(pipeName, ".", clientRequestHandler.Object, logger: logger);
var clientRunning = client.ConnectAsync();
SimulateMultiTurnConversation(1, new[] { activity }, client, logger);
// Assert
Assert.True(verifiedResponse);
}
public static void XUnitLogger_Validates_Parameters()
{
// Arrange
string name = "MyName";
var outputHelper = Mock.Of <ITestOutputHelper>();
var options = new XUnitLoggerOptions()
{
Filter = FilterFalse,
};
// Act and Assert
Assert.Throws <ArgumentNullException>("name", () => new XUnitLogger(null !, outputHelper, options));
Assert.Throws <ArgumentNullException>("outputHelper", () => new XUnitLogger(name, (null as ITestOutputHelper) !, options));
Assert.Throws <ArgumentNullException>("messageSink", () => new XUnitLogger(name, (null as IMessageSink) !, options));
Assert.Throws <ArgumentNullException>("accessor", () => new XUnitLogger(name, (null as ITestOutputHelperAccessor) !, options));
Assert.Throws <ArgumentNullException>("accessor", () => new XUnitLogger(name, (null as IMessageSinkAccessor) !, options));
// Arrange
var logger = new XUnitLogger(name, outputHelper, options);
// Act and Assert
Assert.Throws <ArgumentNullException>("value", () => logger.Filter = null !);
Assert.Throws <ArgumentNullException>("value", () => logger.MessageSinkMessageFactory = null !);
// Arrange
Func <string?, LogLevel, bool> filter = (_, _) => true;
// Act
logger.Filter = filter;
// Assert
logger.Filter.ShouldBeSameAs(filter);
}
public async Task TestFileLogger()
{
var xUnitLogger = new XUnitLogger(_testOutputHelper)
{
LogLevel = LogLevels.Verbose
};
LoggerMapper.RegisterLoggerFor <FileLogger>(xUnitLogger);
// Define a pattern with seconds in it...
const string filenamePattern = "{Processname}-{Timestamp:yyyyMMddHHmmss}{Extension}";
using (var forwardingLogger = new ForwardingLogger {
LogLevel = LogLevels.Verbose
})
{
LoggerTestSupport.TestAllLogMethods(forwardingLogger);
using (var fileLogger = new FileLogger())
{
fileLogger.FilenamePattern = filenamePattern;
fileLogger.ArchiveFilenamePattern = filenamePattern;
forwardingLogger.ReplacedWith(fileLogger);
// Force archiving, as the filename changes
await Task.Delay(2000);
LoggerTestSupport.TestAllLogMethods(fileLogger);
}
}
}
public void ClientTransportCanReceiveMessages()
{
var logger = XUnitLogger.CreateLogger(_testOutput);
using (var connection = new TestWebSocketConnectionFeature())
{
var server = connection.AcceptAsync().GetAwaiter().GetResult();
var client = connection.Client;
var fromTransport = new Pipe(PipeOptions.Default);
var toTransport = new Pipe(PipeOptions.Default);
var listenerRunning = ListenAsync(fromTransport.Reader);
var sut = new WebSocketTransport(new DuplexPipe(toTransport.Reader, fromTransport.Writer), logger);
var clientTransportRunning = sut.ProcessSocketAsync(client, CancellationToken.None);
var messages = new List <byte[]> {
Encoding.UTF8.GetBytes("foo")
};
SendBinaryAsync(server, messages).Wait();
server.CloseAsync(WebSocketCloseStatus.NormalClosure, "Done sending.", CancellationToken.None).Wait();
clientTransportRunning.Wait();
var output = listenerRunning.GetAwaiter().GetResult();
Assert.Equal("foo", Encoding.UTF8.GetString(output[0]));
}
}
public void ClientTransportCanSendMessages()
{
var logger = XUnitLogger.CreateLogger(_testOutput);
using (var connection = new TestWebSocketConnectionFeature())
{
var server = connection.AcceptAsync().GetAwaiter().GetResult();
var client = connection.Client;
var receiverRunning = ReceiveAsync(server);
var fromTransport = new Pipe(PipeOptions.Default);
var toTransport = new Pipe(PipeOptions.Default);
var sut = new WebSocketTransport(client, new DuplexPipe(toTransport.Reader, fromTransport.Writer), logger);
var clientTransportRunning = sut.ConnectAsync(CancellationToken.None);
var messages = new List <byte[]> {
Encoding.UTF8.GetBytes("foo")
};
WriteAsync(toTransport.Writer, messages).Wait();
toTransport.Writer.CompleteAsync().GetAwaiter().GetResult();
clientTransportRunning.Wait();
var output = receiverRunning.GetAwaiter().GetResult();
Assert.Equal("foo", Encoding.UTF8.GetString(output[0]));
}
}
public async Task Integration_KeepAlive()
{
// TODO: Transform this test into a theory and do multi-message, multi-thread, multi-client, etc.
var logger = XUnitLogger.CreateLogger(_outputHelper);
var cts = new CancellationTokenSource();
using (var webSocketFeature = new TestWebSocketConnectionFeature())
{
// Bot / server setup
var botRequestHandler = new Mock <RequestHandler>();
botRequestHandler
.Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None))
.ReturnsAsync(() => new StreamingResponse()
{
StatusCode = 200
});
var socket = await webSocketFeature.AcceptAsync().ConfigureAwait(false);
var connection = new WebSocketStreamingConnection(socket, logger);
var serverTask = connection.ListenAsync(botRequestHandler.Object, cts.Token);
// Client / channel setup
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None))
.ReturnsAsync(() => new StreamingResponse()
{
StatusCode = 200
});
var client = new WebSocketClient(webSocketFeature.Client, "wss://test", clientRequestHandler.Object, logger: logger, closeTimeOut: TimeSpan.FromSeconds(10), keepAlive: TimeSpan.FromMilliseconds(200));
var clientTask = client.ConnectInternalAsync(CancellationToken.None);
// Send request bot (server) -> channel (client)
const string path = "api/version";
const string botToClientPayload = "Hello human, I'm Bender!";
var request = StreamingRequest.CreatePost(path, new StringContent(botToClientPayload));
var responseFromClient = await connection.SendStreamingRequestAsync(request).ConfigureAwait(false);
Assert.Equal(200, responseFromClient.StatusCode);
const string clientToBotPayload = "Hello bot, I'm Calculon!";
var clientRequest = StreamingRequest.CreatePost(path, new StringContent(clientToBotPayload));
// Send request bot channel (client) -> (server)
var clientToBotResult = await client.SendAsync(clientRequest).ConfigureAwait(false);
Assert.Equal(200, clientToBotResult.StatusCode);
await Task.Delay(TimeSpan.FromSeconds(3)).ConfigureAwait(false);
Assert.True(client.IsConnected);
}
}
protected ProviderCommandCoreTests(ProviderService providerService, ITestOutputHelper outputHelper)
{
ProviderService = providerService ?? throw new ArgumentNullException(nameof(providerService));
Logger = XUnitLogger.Create(GetType(), outputHelper);
Test = outputHelper.GetTest();
configuration = new Lazy <IConfiguration>(() => BuildConfiguration(new ConfigurationBuilder()));
}
public MicrosoftAzureDocumentDbTests(AzureCosmosDbTestEnvironment environment, ITestOutputHelper output)
{
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureCosmosDbDiagnosticsSubscriber());
_client = new DocumentClient(new Uri(environment.Endpoint), environment.PrimaryMasterKey);
}
public async Task Integration_Interop_LegacyClient()
{
// TODO: Transform this test into a theory and do multi-message, multi-thread, multi-client, etc.
var logger = XUnitLogger.CreateLogger(_outputHelper);
using (var webSocketFeature = new TestWebSocketConnectionFeature())
{
// Bot / server setup
var botRequestHandler = new Mock <RequestHandler>();
botRequestHandler
.Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None))
.ReturnsAsync(() => new StreamingResponse()
{
StatusCode = 200
});
var socket = await webSocketFeature.AcceptAsync().ConfigureAwait(false);
var connection = new WebSocketStreamingConnection(socket, logger);
var serverTask = Task.Run(() => connection.ListenAsync(botRequestHandler.Object));
// Client / channel setup
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(r => r.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), null, null, CancellationToken.None))
.ReturnsAsync(() => new StreamingResponse()
{
StatusCode = 200
});
using (var client = new Microsoft.Bot.Streaming.Transport.WebSockets.WebSocketClient("wss://test", clientRequestHandler.Object))
{
await client.ConnectInternalAsync(webSocketFeature.Client).ConfigureAwait(false);
// Send request bot (server) -> channel (client)
const string path = "api/version";
const string botToClientPayload = "Hello human, I'm Bender!";
var request = StreamingRequest.CreatePost(path, new StringContent(botToClientPayload));
var responseFromClient = await connection.SendStreamingRequestAsync(request).ConfigureAwait(false);
Assert.Equal(200, responseFromClient.StatusCode);
const string clientToBotPayload = "Hello bot, I'm Calculon!";
var clientRequest = StreamingRequest.CreatePost(path, new StringContent(clientToBotPayload));
// Send request bot channel (client) -> (server)
var clientToBotResult = await client.SendAsync(clientRequest).ConfigureAwait(false);
Assert.Equal(200, clientToBotResult.StatusCode);
client.Disconnect();
}
await serverTask.ConfigureAwait(false);
}
}
protected BlobStorageTestsBase(AzureStorageTestEnvironment environment, ITestOutputHelper output)
{
Environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
Agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
Agent.Subscribe(new AzureBlobStorageDiagnosticsSubscriber());
}
private void RunStreamingCrashTest(Action <WebSocket, TestWebSocketConnectionFeature.WebSocketChannel, WebSocketClient, CancellationTokenSource, CancellationTokenSource> induceCrash)
{
var logger = XUnitLogger.CreateLogger(_testOutput);
var serverCts = new CancellationTokenSource();
var clientCts = new CancellationTokenSource();
using (var connection = new TestWebSocketConnectionFeature())
{
var webSocket = connection.AcceptAsync().Result;
var clientWebSocket = connection.Client;
var bot = new StreamingTestBot((turnContext, cancellationToken) => Task.CompletedTask);
var server = new CloudAdapter(new StreamingTestBotFrameworkAuthentication(), logger);
var serverRunning = server.ProcessAsync(CreateWebSocketUpgradeRequest(webSocket), new Mock <HttpResponse>().Object, bot, serverCts.Token);
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(StreamingResponse.OK()));
using (var client = new WebSocketClient("wss://test", clientRequestHandler.Object, logger: logger))
{
var clientRunning = client.ConnectInternalAsync(clientWebSocket, clientCts.Token);
var activity = new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "test",
Text = "hi"
};
var content = new StringContent(JsonConvert.SerializeObject(activity), Encoding.UTF8, "application/json");
var response = client.SendAsync(StreamingRequest.CreatePost("/api/messages", content)).Result;
Assert.Equal(200, response.StatusCode);
induceCrash(webSocket, clientWebSocket, client, serverCts, clientCts);
clientRunning.Wait();
Assert.True(clientRunning.IsCompletedSuccessfully);
}
serverRunning.Wait();
Assert.True(serverRunning.IsCompletedSuccessfully);
}
}
public AzureQueueStorageDiagnosticListenerTests(AzureStorageTestEnvironment environment, ITestOutputHelper output)
{
_environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureQueueStorageDiagnosticsSubscriber());
}
public MessagingFixture(ITestOutputHelper helper, string roomName)
{
RoomName = roomName;
_logger = new XUnitLogger(helper);
Master = new RocketChatDriverFixture(_logger);
Slave = new RocketChatDriverFixture(_logger);
Fixture = new RocketChatDriverFixture(_logger);
Fixture.InitAsync(Constants.OneUsername, Constants.OnePassword).Wait();
RoomId = Fixture.Driver.CreateChannelAsync(roomName)?.Result?.Result?.RoomId;
}
public MicrosoftAzureServiceBusDiagnosticListenerTests(AzureServiceBusTestEnvironment environment, ITestOutputHelper output)
{
_environment = environment;
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new MicrosoftAzureServiceBusDiagnosticsSubscriber());
_adminClient = new ServiceBusAdministrationClient(environment.ServiceBusConnectionString);
}
public MicrosoftAzureCosmosTests(AzureCosmosDbTestEnvironment environment, ITestOutputHelper output)
{
var logger = new XUnitLogger(LogLevel.Trace, output);
_sender = new MockPayloadSender(logger);
_agent = new ApmAgent(new TestAgentComponents(logger: logger, payloadSender: _sender));
_agent.Subscribe(new AzureCosmosDbDiagnosticsSubscriber());
_client = new CosmosClient(environment.Endpoint, environment.PrimaryMasterKey, new CosmosClientOptions
{
ConnectionMode = ConnectionMode.Gateway
});
}
public async Task GetTest()
{
// arrange
var logger = XUnitLogger.Create <SystemInformationController>(this.testOutputHelper);
var sut = new SystemInformationController(logger);
// act
var result = await sut.Get().AnyContext();
// assert
result.ShouldNotBeNull();
}
public void GetTest()
{
// arrange
var logger = XUnitLogger.Create <EchoController>(this.testOutputHelper);
var sut = new EchoController(logger);
// act
var result = sut.Get();
// assert
result.ShouldNotBeNull();
}
protected void ExecuteFeature <T>(string scenarioKey) where T : IFeature
{
Action <ContainerBuilder> action = builder =>
{
var logger = new XUnitLogger(_output);
builder.RegisterInstance(logger).As <ILogger>().SingleInstance();
};
using (var scope = FootmarkContainer.Container.BeginLifetimeScope("feature", action))
{
IFeature feature = scope.Resolve <T>();
// 执行对应的测试场景
var type = feature.GetType();
var methods = type.GetMethods().Where(x => HasScenarioAttribute(x, scenarioKey));
foreach (var method in methods)
{
method.Invoke(feature, null);
}
}
}
[InlineData(false, true)] // new client, legacy server
public void SimpleActivityTest(bool useLegacyClient, bool useLegacyServer)
{
var logger = XUnitLogger.CreateLogger(_testOutput);
// Arrange
var activities = new[]
{
new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "test",
Text = "hi"
}
};
var verifiedResponses = activities.ToDictionary(a => a.Id, a => false);
var bot = new StreamingTestBot((turnContext, cancellationToken) =>
{
var activityClone = JsonConvert.DeserializeObject <Activity>(JsonConvert.SerializeObject(turnContext.Activity));
activityClone.Text = $"Echo: {turnContext.Activity.Text}";
return(turnContext.SendActivityAsync(activityClone, cancellationToken));
});
var server = CreateTestStreamingTransportServer(useLegacyServer, logger);
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>()))
.Returns <ReceiveRequest, ILogger <RequestHandler>, object, CancellationToken>((request, anonLogger, context, cancellationToken) =>
{
var body = request.ReadBodyAsString();
var response = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings);
Assert.NotNull(response);
Assert.Equal("Echo: hi", response.Text);
verifiedResponses[response.ReplyToId] = true;
return(Task.FromResult(StreamingResponse.OK()));
});
// Act
RunActivityStreamingTest(activities, bot, server, clientRequestHandler.Object, logger, useLegacyClient);
// Assert
Assert.True(verifiedResponses.Values.All(verifiedResponse => verifiedResponse));
}
[InlineData(3, 100, 32, false, false)] // new client, new server
public void ConcurrencyTest(int connectionCount, int messageCount, int threadCount, bool useLegacyClient, bool useLegacyServer)
{
var logger = XUnitLogger.CreateLogger(_testOutput);
var activities = new[]
{
new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "test",
Text = "hi",
Attachments = new List <Attachment>
{
new Attachment
{
Name = @"Resources\architecture-resize.png",
ContentType = "image/png",
ContentUrl = $"data:image/png;base64,{Convert.ToBase64String(File.ReadAllBytes(Path.Combine(Environment.CurrentDirectory, @"Resources", "architecture-resize.png")))}",
}
}
}
};
var bot = new StreamingTestBot((turnContext, cancellationToken) =>
{
var response = MessageFactory.Text("Echo: hi");
response.Attachments = new List <Attachment>
{
new Attachment
{
Name = @"Resources\architecture-resize.png",
ContentType = "image/png",
ContentUrl = $"data:image/png;base64,{Convert.ToBase64String(File.ReadAllBytes(Path.Combine(Environment.CurrentDirectory, @"Resources", "architecture-resize.png")))}",
}
};
return(turnContext.SendActivityAsync(response, cancellationToken));
});
var server = CreateTestStreamingTransportServer(useLegacyServer, logger);
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>()))
.Returns <ReceiveRequest, ILogger <RequestHandler>, object, CancellationToken>((request, anonLogger, context, cancellationToken) =>
{
try
{
var body = request.ReadBodyAsString();
var response = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings);
Assert.NotNull(response);
Assert.Equal($"Echo: {activities.FirstOrDefault(a => a.Id == response.ReplyToId)?.Text}", response.Text);
Assert.Equal(1, response.Attachments.Count);
return(Task.FromResult(StreamingResponse.OK()));
}
catch (Exception e)
{
return(Task.FromResult(StreamingResponse.InternalServerError(new StringContent(e.ToString()))));
}
});
var connections = new Task[connectionCount];
for (var i = 0; i < connectionCount; i++)
{
connections[i] = Task.Factory.StartNew(() =>
RunActivityStreamingTest(activities, bot, server, clientRequestHandler.Object, logger, useLegacyClient, messageCount, threadCount));
}
Task.WhenAll(connections).Wait();
}
[InlineData(false, true)] // new client, legacy server
public void ActivityWithAttachmentsTest(bool useLegacyClient, bool useLegacyServer)
{
var logger = XUnitLogger.CreateLogger(_testOutput);
// Arrange
var activities = new[]
{
new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "test",
Text = "1"
},
new Activity
{
Id = Guid.NewGuid().ToString("N"),
Type = ActivityTypes.Message,
From = new ChannelAccount {
Id = "testUser"
},
Conversation = new ConversationAccount {
Id = Guid.NewGuid().ToString("N")
},
Recipient = new ChannelAccount {
Id = "testBot"
},
ServiceUrl = "wss://InvalidServiceUrl/api/messages",
ChannelId = "test",
Text = "2",
Attachments = new List <Attachment>
{
new Attachment
{
Name = @"Resources\architecture-resize.png",
ContentType = "image/png",
ContentUrl = $"data:image/png;base64,{Convert.ToBase64String(File.ReadAllBytes(Path.Combine(Environment.CurrentDirectory, @"Resources", "architecture-resize.png")))}",
}
}
}
};
var verifiedResponses = activities.ToDictionary(a => a.Id, a => false);
var bot = new StreamingTestBot((turnContext, cancellationToken) =>
{
switch (turnContext.Activity.Text)
{
case "1":
var response1 = MessageFactory.Text("Echo: 1");
response1.Attachments = new List <Attachment>
{
new Attachment
{
Name = @"Resources\architecture-resize.png",
ContentType = "image/png",
ContentUrl = $"data:image/png;base64,{Convert.ToBase64String(File.ReadAllBytes(Path.Combine(Environment.CurrentDirectory, @"Resources", "architecture-resize.png")))}",
}
};
return(turnContext.SendActivityAsync(response1, cancellationToken));
case "2":
var response2 = MessageFactory.Text("Echo: 2");
return(turnContext.SendActivityAsync(response2, cancellationToken));
default:
throw new ApplicationException("Unknown Activity!");
}
});
var server = CreateTestStreamingTransportServer(useLegacyServer, logger);
var clientRequestHandler = new Mock <RequestHandler>();
clientRequestHandler
.Setup(h => h.ProcessRequestAsync(It.IsAny <ReceiveRequest>(), It.IsAny <ILogger <RequestHandler> >(), It.IsAny <object>(), It.IsAny <CancellationToken>()))
.Returns <ReceiveRequest, ILogger <RequestHandler>, object, CancellationToken>((request, anonLogger, context, cancellationToken) =>
{
try
{
var body = request.ReadBodyAsString();
var response = JsonConvert.DeserializeObject <Activity>(body, SerializationSettings.DefaultDeserializationSettings);
Assert.NotNull(response);
Assert.Equal($"Echo: {activities.FirstOrDefault(a => a.Id == response.ReplyToId)?.Text}", response.Text);
verifiedResponses[response.ReplyToId] = true;
return(Task.FromResult(StreamingResponse.OK()));
}
catch (Exception e)
{
return(Task.FromResult(StreamingResponse.InternalServerError(new StringContent(e.ToString()))));
}
});
// Act
RunActivityStreamingTest(activities, bot, server, clientRequestHandler.Object, logger, useLegacyClient);
// Assert
Assert.True(verifiedResponses.Values.All(verifiedResponse => verifiedResponse));
}
public static ILogger <T> Create <T>()
{
var logger = new XUnitLogger <T>();
return(logger);
}
public JobManagerTest(ITestOutputHelper testOutputHelper)
{
var logger = new XUnitLogger <JobManager>(testOutputHelper);
_jobManager = new JobManager(new TestActivator(), logger, new InMemoryStorage());
}
public SandboxFacts(ITestOutputHelper helper) : base(helper)
{
_helper = helper;
_xUnitLogger = new XUnitLogger(_helper);
}
public LaunchPadControllerTest(ITestOutputHelper output)
{
_spaceXCaller = new SpaceXApiCallerFake();
_logger = new XUnitLogger <LaunchPadController>(output);
_launchPadController = new LaunchPadController(_logger, _spaceXCaller);
}
public LoggerTestEnvironment(XUnitLogger logger, LoggerAssertHandler handler)
{
this.logger = logger;
this.handler = handler;
startIndex = logger.MessageLog.Count;
}
public static ILogger <T> Create <T>(ITestOutputHelper output)
{
var logger = new XUnitLogger <T>(output);
return(logger);
}
public DdpFacts(ITestOutputHelper helper)
{
_helper = new XUnitLogger(helper);
}
