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); }