public async Task Send_MultipleRequests_Sequential_Success()
{
await RunMultiStreamTest(
async (client, uri) =>
{
foreach ((var testIdx, var headers, var content, var trailingHeaders) in InterleavedData())
{
await using ValueHttpRequest request = (await client.CreateNewRequestAsync(Version, HttpVersionPolicy.RequestVersionExact)).Value;
await ClientSendHelperAsync(request, uri, testIdx, headers, content, trailingHeaders);
}
},
async server =>
{
foreach ((var testIdx, var headers, var content, var trailingHeaders) in InterleavedData())
{
await using HttpTestStream serverStream = await server.AcceptStreamAsync();
HttpTestFullRequest request = await serverStream.ReceiveAndSendAsync();
Assert.True(request.Headers.Contains(headers));
Assert.Equal(string.Join("", content), request.Content);
if (trailingHeaders is not null)
{
Assert.True(request.TrailingHeaders.Contains(trailingHeaders));
}
}
}, millisecondsTimeout : DefaultTestTimeout * 10);
}
public async Task Send_NonChunkedRequest_Success(int testIdx, TestHeadersSink requestHeaders, List <string> requestContent)
{
_ = testIdx; // only used to assist debugging.
await RunSingleStreamTest(
async (clientRequest, serverUri) =>
{
long contentLength = requestContent.Sum(x => (long)x.Length);
clientRequest.ConfigureRequest(contentLength, hasTrailingHeaders: false);
clientRequest.WriteRequest(HttpMethod.Post, serverUri);
clientRequest.WriteHeader("Content-Length", contentLength.ToString(CultureInfo.InvariantCulture));
clientRequest.WriteHeaders(requestHeaders);
foreach (string content in requestContent)
{
await clientRequest.WriteContentAsync(content);
}
await clientRequest.CompleteRequestAsync();
},
async serverStream =>
{
HttpTestFullRequest request = await serverStream.ReceiveAndSendAsync();
Assert.True(request.Headers.Contains(requestHeaders));
Assert.Equal(string.Join("", requestContent), request.Content);
});
}
public async Task Send_ChunkedRequest_Success(int testIdx, TestHeadersSink requestHeaders, List <string> requestContent, TestHeadersSink requestTrailingHeaders)
{
_ = testIdx; // only used to assist debugging.
await RunSingleStreamTest(
async (client, serverUri) =>
{
long contentLength = requestContent.Sum(x => (long)x.Length);
client.ConfigureRequest(contentLength, hasTrailingHeaders: true);
client.WriteRequest(HttpMethod.Post, serverUri);
client.WriteHeaders(requestHeaders);
foreach (string content in requestContent)
{
await client.WriteContentAsync(content);
}
client.WriteTrailingHeaders(requestTrailingHeaders);
await client.CompleteRequestAsync();
},
async server =>
{
HttpTestFullRequest request = await server.ReceiveAndSendAsync();
if (request.Version.Major == 1)
{
Assert.Equal("chunked", request.Headers.GetSingleValue("transfer-encoding"));
}
Assert.True(request.Headers.Contains(requestHeaders));
Assert.Equal(string.Join("", requestContent), request.Content);
Assert.True(request.TrailingHeaders.Contains(requestTrailingHeaders));
});
}
public async Task <HttpTestFullRequest> ReceiveAndSendChunkedAsync(int statusCode = 200, TestHeadersSink?headers = null, IList <string>?content = null, TestHeadersSink?trailingHeaders = null)
{
HttpTestFullRequest request = await ReceiveFullRequestAsync().ConfigureAwait(false);
await SendChunkedResponseAsync(statusCode, headers, content, trailingHeaders).ConfigureAwait(false);
return(request);
}
public async Task Pipelining_Success()
{
const int PipelineLength = 10;
await RunMultiStreamTest(
async (client, serverUri) =>
{
var tasks = new Task[PipelineLength];
for (int i = 0; i < tasks.Length; ++i)
{
tasks[i] = MakeRequest(i);
}
await tasks.WhenAllOrAnyFailed(10_000);
async Task MakeRequest(int requestNo)
{
await using ValueHttpRequest request = (await client.CreateNewRequestAsync(Version, HttpVersionPolicy.RequestVersionExact)).Value;
request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
request.WriteRequest(HttpMethod.Get, serverUri);
request.WriteHeader("X-Request-No", requestNo.ToString(CultureInfo.InvariantCulture));
await request.CompleteRequestAsync();
TestHeadersSink headers = await request.ReadAllHeadersAsync();
Assert.Equal(requestNo.ToString(CultureInfo.InvariantCulture), headers.GetSingleValue("X-Response-No"));
}
},
async server =>
{
var streams = new (HttpTestStream, HttpTestFullRequest)[PipelineLength];
for (int i = 0; i < streams.Length; ++i)
{
HttpTestStream stream = await server.AcceptStreamAsync();
HttpTestFullRequest request = await stream.ReceiveFullRequestAsync();
Assert.Equal(i.ToString(CultureInfo.InvariantCulture), request.Headers.GetSingleValue("X-Request-No"));
streams[i] = (stream, request);
}
for (int i = 0; i < streams.Length; ++i)
{
(HttpTestStream stream, HttpTestFullRequest request) = streams[i];
var responseHeaders = new TestHeadersSink()
{
{ "X-Response-No", i.ToString(CultureInfo.InvariantCulture) }
};
await stream.SendResponseAsync(headers: responseHeaders);
await stream.DisposeAsync();
}
});
public async Task Send_NonChunkedRequest_Success(int testIdx, TestHeadersSink requestHeaders, List <string> requestContent)
{
await RunSingleStreamTest(
async (clientRequest, serverUri) =>
{
await ClientSendHelperAsync(clientRequest, serverUri, testIdx, requestHeaders, requestContent, requestTrailingHeaders: null);
},
async serverStream =>
{
HttpTestFullRequest request = await serverStream.ReceiveAndSendAsync();
Assert.True(request.Headers.Contains(requestHeaders));
Assert.Equal(string.Join("", requestContent), request.Content);
});
}
public async Task HeadersSend_Success(TestHeadersSink requestHeaders)
{
await RunSingleStreamTest(
async (clientRequest, serverUri) =>
{
clientRequest.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
clientRequest.WriteRequest(HttpMethod.Get, serverUri);
clientRequest.WriteHeaders(requestHeaders);
await clientRequest.CompleteRequestAsync();
},
async serverStream =>
{
HttpTestFullRequest request = await serverStream.ReceiveAndSendAsync();
Assert.True(request.Headers.Contains(requestHeaders));
});
}
public async Task Receive_LWS_Success()
{
await RunSingleStreamTest(
async (clientRequest, serverUri) =>
{
clientRequest.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
clientRequest.WriteRequest(HttpMethod.Get, serverUri);
await clientRequest.CompleteRequestAsync();
TestHeadersSink responseHeaders = await clientRequest.ReadAllHeadersAsync();
Assert.Equal("foo bar baz", responseHeaders.GetSingleValue("X-Test-Header"));
},
async serverStream =>
{
HttpTestFullRequest request = await serverStream.ReceiveFullRequestAsync();
await((Http1TestStream)serverStream).SendRawResponseAsync("HTTP/1.1 200 OK\r\nX-Test-Header: foo\r\n\tbar\r\n baz\r\n\r\n");
});
}
public async Task Send_ChunkedRequest_Success(int testIdx, TestHeadersSink requestHeaders, List <string> requestContent, TestHeadersSink requestTrailingHeaders)
{
await RunSingleStreamTest(
async (client, serverUri) =>
{
await ClientSendHelperAsync(client, serverUri, testIdx, requestHeaders, requestContent, requestTrailingHeaders);
},
async server =>
{
HttpTestFullRequest request = await server.ReceiveAndSendAsync();
if (request.Version.Major == 1)
{
Assert.Equal("chunked", request.Headers.GetSingleValue("transfer-encoding"));
}
Assert.True(request.Headers.Contains(requestHeaders));
Assert.Equal(string.Join("", requestContent), request.Content);
Assert.True(request.TrailingHeaders.Contains(requestTrailingHeaders));
});
}
