public void Response_InternalServerError_Success()
{
var r = StreamingResponse.InternalServerError();
Assert.Equal((int)HttpStatusCode.InternalServerError, r.StatusCode);
Assert.Null(r.Streams);
}
public override async Task <StreamingResponse> ProcessRequestAsync(ReceiveRequest request, ILogger <RequestHandler> logger, object context = null, CancellationToken cancellationToken = default)
{
var response = await request.ReadBodyAsJsonAsync <Schema.Activity>().ConfigureAwait(false);
System.Console.WriteLine($"[Bot]: {response?.Text}");
return(await Task.FromResult(StreamingResponse.OK()).ConfigureAwait(false));
}
public void Response_OK_Success()
{
var r = StreamingResponse.OK();
Assert.Equal((int)HttpStatusCode.OK, r.StatusCode);
Assert.Null(r.Streams);
}
public void Response_Forbidden_Success()
{
var r = StreamingResponse.Forbidden();
Assert.Equal((int)HttpStatusCode.Forbidden, r.StatusCode);
Assert.Null(r.Streams);
}
public void Response_NotFound_Success()
{
var r = StreamingResponse.NotFound();
Assert.Equal((int)HttpStatusCode.NotFound, r.StatusCode);
Assert.Null(r.Streams);
}
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 void Response_NullProperties()
{
var r = new StreamingResponse();
Assert.Equal(0, r.StatusCode);
Assert.Null(r.Streams);
}
// GET api/streamingresponse
public HttpResponseMessage Get()
{
HttpResponseMessage response = Request.CreateResponse();
StreamingResponse streamingResponse = new StreamingResponse();
response.Content = new PushStreamContent(streamingResponse.WriteToStream, new MediaTypeHeaderValue("text/plain"));
return(response);
}
public void Response_AddStream_Null_Throws()
{
var r = new StreamingResponse();
Assert.Throws <ArgumentNullException>(() =>
{
r.AddStream(null);
});
}
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 void Response_Create_WithBody_Success()
{
var s = new StringContent("hi");
var r = StreamingResponse.CreateResponse(HttpStatusCode.OK, s);
Assert.Equal((int)HttpStatusCode.OK, r.StatusCode);
Assert.NotNull(r.Streams);
Assert.Single(r.Streams);
Assert.Equal(s, r.Streams[0].Content);
}
public void Response_AddStream_Success()
{
var r = new StreamingResponse();
var s = new StringContent("hi");
r.AddStream(s);
Assert.NotNull(r.Streams);
Assert.Single(r.Streams);
Assert.Equal(s, r.Streams[0].Content);
}
public async Task ResponseDisassembler_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var disassembler = new ResponseDisassembler(sender, Guid.NewGuid(), StreamingResponse.OK());
await disassembler.DisassembleAsync();
Assert.AreEqual(2, transport.Buffers.Count);
}
private void HandleException(EventHandler toFire, string hash, StreamingResponse <ChunkResponse> response)
{
switch (ExceptionMode)
{
case ChunkExceptionMode.Throw:
throw new ChunkException(response.Data);
case ChunkExceptionMode.EmitEvents:
FireEvent(toFire, new ChunkExceptionEventArgs {
Hash = hash
});
break;
}
}
public void SendToServer(StreamingRequest request, StreamingResponse expectedResponse, Func <StreamingRequest, StreamingResponse, ReceiveResponse, Task> validate, Func <ReceiveRequest, Task> validateRequest = null)
{
_responses.Add(GetRequestKey(request), new PendingRequest()
{
Response = expectedResponse, ValidateRequest = validateRequest
});
_sendToServer.Add(new PendingAction()
{
Request = request,
ExpectedResponse = expectedResponse,
Validate = validate,
ToClient = false,
});
}
public async Task ResponseExtensions_SetBodyString_Success()
{
var r = new StreamingResponse();
r.SetBody("123");
Assert.NotNull(r.Streams);
Assert.Single(r.Streams);
Assert.Equal(typeof(StringContent), r.Streams[0].Content.GetType());
var s = await r.Streams[0].Content.ReadAsStringAsync().ConfigureAwait(false);
Assert.Equal("123", s);
}
public async Task SendResponseAsync()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var ops = new SendOperations(sender);
var content = new StringContent("/a/b", Encoding.ASCII);
var response = StreamingResponse.CreateResponse(HttpStatusCode.OK, content);
await ops.SendResponseAsync(Guid.NewGuid(), response);
Assert.Equal(4, transport.Buffers.Count);
}
public IChunk GetChunk(string hash)
{
StreamingResponse <ChunkResponse> response = SendRequest(new ChunkRequest
{
Operation = ChunkOperation.Get,
Hash = hash
});
if (!response.Data.Success)
{
HandleException(GetChunkException, hash, response);
}
return(response.Data.Chunk);
}
public void SetChunk(IChunk chunkData)
{
StreamingResponse <ChunkResponse> response = SendRequest(new ChunkRequest
{
Operation = ChunkOperation.Set,
Chunk = new Chunk
{
Hash = chunkData.Hash,
Data = chunkData.Data
}
});
if (!response.Data.Success)
{
HandleException(SetChunkException, chunkData.Hash, response);
}
}
public async Task ResponseDisassembler_With_HttpContent_SendsAsFixedLength()
{
var sender = new PayloadSender();
var transport = new MockTransportSender();
sender.Connect(transport);
var content = new StringContent("{'a': 55}", Encoding.UTF8, "application/json");
var response = StreamingResponse.CreateResponse(System.Net.HttpStatusCode.OK, content);
var disassembler = new ResponseDisassembler(sender, Guid.NewGuid(), response);
await disassembler.DisassembleAsync();
Assert.Equal(2, transport.Buffers.Count);
}
public void ResponseExtensions_SetBody_Null_Does_Not_Throw()
{
var r = new StreamingResponse();
Exception ex = null;
try
{
r.SetBody(null);
}
catch (Exception caughtEx)
{
ex = caughtEx;
}
finally
{
Assert.Null(ex);
}
}
public async Task SendResponseAsync(Guid id, StreamingResponse response)
{
var disassembler = new ResponseDisassembler(_payloadSender, id, response);
await disassembler.Disassemble().ConfigureAwait(false);
if (response.Streams != null)
{
var tasks = new List <Task>(response.Streams.Count());
foreach (var contentStream in response.Streams)
{
var contentDisassembler = new ResponseMessageStreamDisassembler(_payloadSender, contentStream);
tasks.Add(contentDisassembler.Disassemble());
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
public async Task ResponseExtensions_SetBody_Success()
{
var r = new StreamingResponse();
var a = new Activity()
{
Text = "hi", Type = "message"
};
r.SetBody(a);
Assert.IsNotNull(r.Streams);
Assert.AreEqual(1, r.Streams.Count);
Assert.AreEqual(typeof(StringContent), r.Streams[0].Content.GetType());
var s = await r.Streams[0].Content.ReadAsAsync <Activity>().ConfigureAwait(false);
Assert.AreEqual(a.Text, s.Text);
Assert.AreEqual(a.Type, s.Type);
}
public async Task SendResponseAsync(Header header, StreamingResponse response, CancellationToken cancellationToken)
{
if (header == null)
{
throw new ArgumentNullException(nameof(header));
}
if (header.Type != PayloadTypes.Response)
{
throw new InvalidOperationException($"StreamingSession SendResponseAsync expected Response payload, but instead received a payload of type {header.Type}");
}
if (response == null)
{
throw new ArgumentNullException(nameof(response));
}
var payload = new ResponsePayload()
{
StatusCode = response.StatusCode,
};
if (response.Streams != null)
{
payload.Streams = new List <StreamDescription>();
foreach (var contentStream in response.Streams)
{
var description = GetStreamDescription(contentStream);
payload.Streams.Add(description);
}
}
await _sender.SendResponseAsync(header.Id, payload, cancellationToken).ConfigureAwait(false);
if (response.Streams != null)
{
foreach (var stream in response.Streams)
{
await _sender.SendStreamAsync(stream.Id, await stream.Content.ReadAsStreamAsync().ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
}
}
}
public VideoViewRenderer(Context context) : base(context)
{
// https://github.com/square/okhttp/issues/3372
httpClient ??= new OkHttpClient().NewBuilder()
.WriteTimeout(5, Java.Util.Concurrent.TimeUnit.Minutes)
.ReadTimeout(5, Java.Util.Concurrent.TimeUnit.Minutes)
.AddInterceptor(chain =>
{
var request = chain.Request();
try
{
var response = chain.Proceed(request);
if (response.IsSuccessful)
{
var body = response.Body();
var contentLength = body.ContentLength();
StreamingResponse?.Invoke(this, new StreamingResponseEventArgs(contentLength));
}
return(response);
}
catch (Java.IO.InterruptedIOException ex)
{
var contentLength = ex.BytesTransferred;
StreamingResponse?.Invoke(this, new StreamingResponseEventArgs(contentLength));
PlaybackError?.Invoke(this, new PlaybackErrorEventArgs(ex));
return(DefaultEmptyHttpResponse(request));
}
catch (Exception ex)
{
if (ex is Java.Net.ConnectException)
{
}
if (ex is Java.Net.UnknownHostException)
{
// probably no internet
}
PlaybackError?.Invoke(this, new PlaybackErrorEventArgs(ex));
return(DefaultEmptyHttpResponse(request));
}
})
.Build();
}
public override async Task <StreamingResponse> ProcessRequestAsync(ReceiveRequest request, ILogger <RequestHandler> logger, object context = null, CancellationToken cancellationToken = default(CancellationToken))
{
if (request.Verb == "POST" && request.Path == _postActivitiesPath)
{
var activitySet = await ReadOptionalBodyAsJson <ActivitySet>(request).ConfigureAwait(false);
if (request.Streams.Count > 1)
{
var attachmentDictionary = request.Streams.Skip(1).ToDictionary(a => a.Id);
int streamsMappedtoActivitiesCount = 0;
foreach (var activity in activitySet.Activities)
{
if (activity.Attachments == null || activity.Attachments.Count == 0)
{
continue;
}
for (int i = 0; i < activity.Attachments.Count(); i++)
{
if (string.Equals(activity.Attachments[i].ContentType, "bf-stream", StringComparison.InvariantCultureIgnoreCase))
{
var id = Guid.Parse(activity.Attachments[i].Content.ToString());
var stream = attachmentDictionary[id];
activity.Attachments[i] = new Attachment()
{
ContentType = stream.ContentType, Content = stream.Stream
};
streamsMappedtoActivitiesCount++;
}
}
if (streamsMappedtoActivitiesCount == request.Streams.Count - 1)
{
break;
}
}
}
_receiveActivities(activitySet);
return(StreamingResponse.OK());
}
return(StreamingResponse.NotFound());
}
public async Task ResponseExtensions_SetBody_Success()
{
var r = new StreamingResponse();
var a = new Activity()
{
Text = "hi", Type = "message"
};
r.SetBody(a);
Assert.NotNull(r.Streams);
Assert.Single(r.Streams);
Assert.Equal(typeof(StringContent), r.Streams[0].Content.GetType());
var s = JsonConvert.DeserializeObject <Activity>(await r.Streams[0].Content.ReadAsStringAsync().ConfigureAwait(false));
Assert.Equal(a.Text, s.Text);
Assert.Equal(a.Type, s.Type);
}
public void Response_AddStream_ExistingList_Success()
{
var r = new StreamingResponse();
var s = new StringContent("hi");
var s2 = new StringContent("hello");
r.Streams = new List <ResponseMessageStream> {
new ResponseMessageStream()
{
Content = s2
}
};
r.AddStream(s);
Assert.NotNull(r.Streams);
Assert.Equal(2, r.Streams.Count);
Assert.Equal(s2, r.Streams[0].Content);
Assert.Equal(s, r.Streams[1].Content);
}
public void CanServe()
{
ConsoleLogger logger = new ConsoleLogger {
AddDetails = false
};
Encoding encoding = Encoding.UTF8;
int port = RandomNumber.Between(8081, 65535);
logger.StartLoggingThread();
TestBinaryServer server = new TestBinaryServer(logger, port);
server.Start();
StreamingClient client = new StreamingClient("localhost", port);
StreamingResponse response = client.SendWrappedMessage((object)"this is a test");
Console.WriteLine("Response: " + response.Body);
response = client.SendWrappedMessage((object)"second message");
Console.WriteLine("Second resposne: " + response.Body);
Thread.Sleep(1000);
}
public async Task VideoStreamingAsync(string strId, string strToken, Action <StreamingResponse> action)
{
try
{
string url = GetUrlStreaming(strId, strToken);
string strResBody = String.Empty;
StreamingResponse streamingResponse = null;
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
//client.Timeout = TimeSpan.FromMilliseconds(Timeout.Infinite);
Stream stream = await client.GetStreamAsync(url);
StreamReader reader = new StreamReader(stream);
while (!reader.EndOfStream)
{
strResBody = Utilis.ConvertToUnicode(reader.ReadLine());
if (strResBody.Contains("no_data") || strResBody.Contains("has_emoji"))
{
LiveVideoDataResp objVideoInfo = await GetStatusLiveVideo(strId, strToken);
if (objVideoInfo == null || !objVideoInfo.Status.Equals("LIVE"))
{
break;
}
continue;
}
streamingResponse = JsonConvert.DeserializeObject <StreamingResponse>(strResBody);
action(streamingResponse);
}
}
catch (HttpRequestException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
}
