public async Task CanSendData()
{
var data = new byte[] { 1, 1, 2, 3, 5, 8 };
var testHttpHandler = new TestHttpMessageHandler();
var sendTcs = new TaskCompletionSource <byte[]>();
var longPollTcs = new TaskCompletionSource <HttpResponseMessage>();
testHttpHandler.OnLongPoll(cancellationToken => longPollTcs.Task);
testHttpHandler.OnSocketSend((buf, cancellationToken) =>
{
sendTcs.TrySetResult(buf);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.Accepted)));
});
await WithConnectionAsync(
CreateConnection(testHttpHandler),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(data).DefaultTimeout();
Assert.Equal(data, await sendTcs.Task.DefaultTimeout());
longPollTcs.TrySetResult(ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
});
}
public async Task CanReceiveData()
{
var testHttpHandler = new TestHttpMessageHandler();
// Set the long poll up to return a single message over a few polls.
var requestCount = 0;
var messageFragments = new[] { "This ", "is ", "a ", "test" };
testHttpHandler.OnLongPoll(cancellationToken =>
{
if (requestCount >= messageFragments.Length)
{
return(ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
}
var resp = ResponseUtils.CreateResponse(HttpStatusCode.OK, messageFragments[requestCount]);
requestCount += 1;
return(resp);
});
testHttpHandler.OnSocketSend((_, __) => ResponseUtils.CreateResponse(HttpStatusCode.Accepted));
await WithConnectionAsync(
CreateConnection(testHttpHandler),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
Assert.Contains("This is a test", Encoding.UTF8.GetString(await connection.Transport.Input.ReadAllAsync()));
});
}
public async Task HttpConnectionFailsAfterFirstRetryFailsServerSentEvents()
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
var accessTokenCallCount = 0;
testHttpHandler.OnNegotiate((_, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
testHttpHandler.OnSocketSend((_, _) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized));
});
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var stream = new BlockingStream(tcs);
testHttpHandler.OnRequest((request, next, token) =>
{
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream))));
});
Task <string> AccessTokenProvider()
{
accessTokenCallCount++;
return(Task.FromResult(accessTokenCallCount.ToString(CultureInfo.InvariantCulture)));
}
await WithConnectionAsync(
CreateConnection(testHttpHandler, transportType : HttpTransportType.ServerSentEvents, accessTokenProvider : AccessTokenProvider),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1"));
await Assert.ThrowsAsync <HttpRequestException>(async() => await connection.Transport.Input.ReadAllAsync());
});
// 1 negotiate + 1 retry stream request
Assert.Equal(2, accessTokenCallCount);
}
public async Task TransportPipeIsCompletedWhenErrorOccursInTransport()
{
bool ExpectedErrors(WriteContext writeContext)
{
return(writeContext.LoggerName == typeof(LongPollingTransport).FullName &&
writeContext.EventId.Name == "ErrorSending");
}
using (StartVerifiableLog(expectedErrorsFilter: ExpectedErrors))
{
var httpHandler = new TestHttpMessageHandler();
var longPollResult = new TaskCompletionSource <HttpResponseMessage>();
httpHandler.OnLongPoll(cancellationToken =>
{
cancellationToken.Register(() =>
{
longPollResult.TrySetResult(ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
});
return(longPollResult.Task);
});
httpHandler.OnLongPollDelete(cancellationToken => ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
httpHandler.OnSocketSend((data, _) =>
{
Assert.Collection(data, i => Assert.Equal(0x42, i));
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError)));
});
await WithConnectionAsync(
CreateConnection(httpHandler, LoggerFactory),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(new byte[] { 0x42 }).DefaultTimeout();
await Assert.ThrowsAsync <HttpRequestException>(async() => await connection.Transport.Input.ReadAsync());
});
}
}
public async Task HttpConnectionRetriesAccessTokenProviderWhenAuthFailsServerSentEvents()
{
var testHttpHandler = new TestHttpMessageHandler(autoNegotiate: false);
var requestsExecuted = false;
var accessTokenCallCount = 0;
testHttpHandler.OnNegotiate((_, cancellationToken) =>
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, ResponseUtils.CreateNegotiationContent()));
});
var sendRequestExecuted = false;
var sendFinishedTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
testHttpHandler.OnSocketSend((_, _) =>
{
if (!sendRequestExecuted)
{
sendRequestExecuted = true;
return(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized));
}
sendFinishedTcs.SetResult();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var stream = new BlockingStream(tcs);
testHttpHandler.OnRequest((request, next, token) =>
{
if (!requestsExecuted)
{
requestsExecuted = true;
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.Unauthorized)));
}
Assert.Equal("Bearer", request.Headers.Authorization.Scheme);
Assert.Equal(accessTokenCallCount.ToString(CultureInfo.InvariantCulture), request.Headers.Authorization.Parameter);
return(Task.FromResult(ResponseUtils.CreateResponse(HttpStatusCode.OK, new StreamContent(stream))));
});
Task <string> AccessTokenProvider()
{
accessTokenCallCount++;
return(Task.FromResult(accessTokenCallCount.ToString(CultureInfo.InvariantCulture)));
}
await WithConnectionAsync(
CreateConnection(testHttpHandler, transportType : HttpTransportType.ServerSentEvents, accessTokenProvider : AccessTokenProvider),
async (connection) =>
{
await connection.StartAsync().DefaultTimeout();
await connection.Transport.Output.WriteAsync(Encoding.UTF8.GetBytes("Hello world 1"));
await sendFinishedTcs.Task;
tcs.TrySetResult();
await connection.Transport.Input.ReadAllAsync();
});
// 1 negotiate + 1 retry stream request + 1 retry send
Assert.Equal(3, accessTokenCallCount);
}
