public async Task Body_PostContentLengthX_StreamWithXBytes()
{
OwinHttpListener listener = CreateServer(
env =>
{
string[] values;
var requestHeaders = env.Get <IDictionary <string, string[]> >("owin.RequestHeaders");
Assert.True(requestHeaders.TryGetValue("Content-length", out values));
Assert.Single(values);
Assert.Equal("11", values[0]);
var requestBody = env.Get <Stream>("owin.RequestBody");
Assert.NotNull(requestBody);
var buffer = new MemoryStream();
requestBody.CopyTo(buffer);
Assert.Equal(11, buffer.Length);
return(Task.FromResult(0));
},
HttpServerAddress);
var request = new HttpRequestMessage(HttpMethod.Post, HttpClientAddress);
request.Content = new StringContent("Hello World");
await SendRequest(listener, request);
}
public async Task OwinHttpListenerResponse_101ResponseWithBody_BodyIgnoredByClient()
{
OwinHttpListener listener = CreateServer(
env =>
{
env["owin.ResponseStatusCode"] = 101;
var responseStream = env.Get <Stream>("owin.ResponseBody");
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders["content-length"] = new string[] { "10" };
responseStream.Write(new byte[10], 0, 10);
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(HttpClientAddress);
Assert.Equal(HttpStatusCode.SwitchingProtocols, response.StatusCode);
Assert.Equal("Switching Protocols", response.ReasonPhrase);
Assert.Equal(2, response.Headers.Count()); // Date, Server
Assert.True(response.Headers.Date.HasValue);
Assert.Equal(1, response.Headers.Server.Count);
Assert.Equal(0, (await response.Content.ReadAsByteArrayAsync()).Length);
}
}
public void Disconnect_ClientDisconnects_EventFires()
{
var requestReceived = new ManualResetEvent(false);
var requestCanceled = new ManualResetEvent(false);
OwinHttpListener listener = CreateServer(
env =>
{
GetCallCancelled(env).Register(() => requestCanceled.Set());
requestReceived.Set();
Assert.True(requestCanceled.WaitOne(1000));
return(Task.FromResult(0));
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
var requestTask = client.GetAsync(HttpClientAddress);
Assert.True(requestReceived.WaitOne(1000));
client.CancelPendingRequests();
Assert.True(requestCanceled.WaitOne(1000));
Assert.Throws <AggregateException>(() => requestTask.Result);
}
}
private OwinHttpListener CreateServer(AppFunc app, string[] addressParts)
{
var wrapper = new OwinHttpListener();
wrapper.Start(wrapper.Listener, app, CreateAddress(addressParts), null, null);
return(wrapper);
}
public async Task EndToEnd_HttpsGetRequest_Success()
{
OwinHttpListener listener = CreateServer(
async env =>
{
object obj;
Assert.True(env.TryGetValue("ssl.LoadClientCertAsync", out obj));
Assert.NotNull(obj);
Assert.IsType(typeof(Func <Task>), obj);
var loadCert = (Func <Task>)obj;
await loadCert();
Assert.True(env.TryGetValue("ssl.ClientCertificate", out obj));
Assert.NotNull(obj);
Assert.IsType <X509Certificate2>(obj);
},
HttpsServerAddress);
X509Certificate2 clientCert = FindClientCert();
Assert.NotNull(clientCert);
HttpResponseMessage response = await SendGetRequest(listener, HttpsClientAddress, clientCert);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.Headers.ContentLength.Value);
}
public async Task PathAndPathBase_CorrectlySeperated(string clientString, string serverBasePath,
string expectedBasePath, string expectedPath, string expectedQuery)
{
var fallbackAddress = new string[4];
HttpServerAddress.CopyTo(fallbackAddress, 0);
fallbackAddress[3] = "/";
var serverAddress = new string[4];
HttpServerAddress.CopyTo(serverAddress, 0);
serverAddress[3] = serverBasePath;
clientString = "http://localhost:8080" + clientString;
using (var wrapper = new OwinHttpListener())
{
wrapper.Start(wrapper.Listener, env =>
{
Assert.Equal(expectedBasePath, (string)env["owin.RequestPathBase"]);
Assert.Equal(expectedPath, (string)env["owin.RequestPath"]);
Assert.Equal(expectedQuery, (string)env["owin.RequestQueryString"]);
return(TaskHelpers.Completed());
}, CreateAddresses(fallbackAddress, serverAddress), null, null);
using (var client = new HttpClient())
{
HttpResponseMessage result = await client.GetAsync(clientString);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
}
}
public async Task OwinHttpListenerResponse_OnFirstWrite_OnSendingHeaders()
{
OwinHttpListener listener = CreateServer(
env =>
{
env["owin.ResponseStatusCode"] = 200;
env["owin.ResponseReasonPhrase"] = "Custom";
var responseStream = env.Get <Stream>("owin.ResponseBody");
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
env.Get <Action <Action <object>, object> >("server.OnSendingHeaders")(state => responseHeaders["custom-header"] = new string[] { "customvalue" }, null);
responseHeaders["content-length"] = new string[] { "10" };
responseStream.Write(new byte[10], 0, 10);
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(HttpClientAddress);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("Custom", response.ReasonPhrase);
Assert.Equal(3, response.Headers.Count()); // Date, Server
Assert.True(response.Headers.Date.HasValue);
Assert.Equal(1, response.Headers.Server.Count);
Assert.Equal("customvalue", response.Headers.GetValues("custom-header").First());
Assert.Equal(10, (await response.Content.ReadAsByteArrayAsync()).Length);
}
}
public async Task ErrorInWebSocket_Disconnected()
{
ManualResetEvent sync = new ManualResetEvent(false);
OwinHttpListener listener = CreateServer(env =>
{
var accept = (WebSocketAccept)env["websocket.Accept"];
Assert.NotNull(accept);
accept(
null,
wsEnv =>
{
sync.Set();
throw new Exception("Application WebSocket error.");
});
return(Task.FromResult(0));
},
HttpServerAddress);
using (listener)
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None);
Assert.True(sync.WaitOne(500));
await Assert.ThrowsAsync <WebSocketException>(() => client.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None));
}
}
}
public async Task PathAndQueryParsing_CorrectlySeperated(string clientString, string serverBasePath,
string expectedBasePath, string expectedPath, string expectedQuery)
{
var serverAddress = new string[4];
HttpServerAddress.CopyTo(serverAddress, 0);
serverAddress[3] = serverBasePath;
clientString = "http://localhost:8080" + clientString;
OwinHttpListener listener = CreateServer(env =>
{
Assert.Equal(expectedBasePath, (string)env["owin.RequestPathBase"]);
Assert.Equal(expectedPath, (string)env["owin.RequestPath"]);
Assert.Equal(expectedQuery, (string)env["owin.RequestQueryString"]);
return(TaskHelpers.Completed());
}, serverAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage result = await client.GetAsync(clientString);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
}
public async Task Headers_ReservedHeaders_PassedThrough()
{
OwinHttpListener listener = CreateServer(
env =>
{
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
env.Add("owin.ResponseProtocol", "HTTP/1.0");
responseHeaders.Add("KEEP-alive", new string[] { "TRUE" });
responseHeaders.Add("content-length", new string[] { "0" });
responseHeaders.Add("www-Authenticate", new string[] { "Basic", "NTLM" });
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(HttpClientAddress);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(3, response.Headers.Count()); // Date, Server
Assert.Equal(0, response.Content.Headers.ContentLength);
Assert.Equal(2, response.Headers.WwwAuthenticate.Count());
// The client does not expose KeepAlive
}
}
public async Task Headers_OtherReservedHeaders_PassedThrough()
{
OwinHttpListener listener = CreateServer(
env =>
{
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders.Add("Transfer-Encoding", new string[] { "ChUnKed" });
responseHeaders.Add("CONNECTION", new string[] { "ClOsE" });
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(HttpClientAddress);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(4, response.Headers.Count()); // Date, Server
Assert.Equal("chunked", response.Headers.TransferEncoding.ToString()); // Normalized by server
Assert.True(response.Headers.TransferEncodingChunked.Value);
Assert.Equal("close", response.Headers.Connection.First()); // Normalized by server
Assert.True(response.Headers.ConnectionClose.Value);
}
}
public void BodyDelegate_ThrowsAsync_ConnectionClosed()
{
bool callCancelled = false;
OwinHttpListener listener = CreateServer(
env =>
{
GetCallCancelled(env).Register(() => callCancelled = true);
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders.Add("Content-Length", new string[] { "10" });
var responseStream = env.Get <Stream>("owin.ResponseBody");
responseStream.WriteByte(0xFF);
return(TaskHelpers.FromError(new NotImplementedException()));
},
HttpServerAddress);
try
{
Assert.Throws <AggregateException>(() => SendGetRequest(listener, HttpClientAddress).Result);
}
finally
{
Assert.True(callCancelled);
}
}
public async Task Environment_EmptyGetRequest_RequiredKeysPresentAndCorrect()
{
OwinHttpListener listener = CreateServer(
env =>
{
object ignored;
Assert.True(env.TryGetValue("owin.RequestMethod", out ignored));
Assert.Equal("GET", env["owin.RequestMethod"]);
Assert.True(env.TryGetValue("owin.RequestPath", out ignored));
Assert.Equal("/SubPath", env["owin.RequestPath"]);
Assert.True(env.TryGetValue("owin.RequestPathBase", out ignored));
Assert.Equal("/BaseAddress", env["owin.RequestPathBase"]);
Assert.True(env.TryGetValue("owin.RequestProtocol", out ignored));
Assert.Equal("HTTP/1.1", env["owin.RequestProtocol"]);
Assert.True(env.TryGetValue("owin.RequestQueryString", out ignored));
Assert.Equal("QueryString", env["owin.RequestQueryString"]);
Assert.True(env.TryGetValue("owin.RequestScheme", out ignored));
Assert.Equal("http", env["owin.RequestScheme"]);
Assert.True(env.TryGetValue("owin.Version", out ignored));
Assert.Equal("1.0", env["owin.Version"]);
return(TaskHelpers.Completed());
},
HttpServerAddress);
await SendGetRequest(listener, HttpClientAddress + "SubPath?QueryString");
}
public async Task Body_PostChunkedX_StreamWithXBytes()
{
OwinHttpListener listener = CreateServer(
env =>
{
string[] values;
var requestHeaders = env.Get <IDictionary <string, string[]> >("owin.RequestHeaders");
Assert.True(requestHeaders.TryGetValue("Transfer-Encoding", out values));
Assert.Equal(1, values.Length);
Assert.Equal("chunked", values[0]);
var requestBody = env.Get <Stream>("owin.RequestBody");
Assert.NotNull(requestBody);
var buffer = new MemoryStream();
requestBody.CopyTo(buffer);
Assert.Equal(11, buffer.Length);
return(TaskHelpers.Completed());
},
HttpServerAddress);
var request = new HttpRequestMessage(HttpMethod.Post, HttpClientAddress);
request.Headers.TransferEncodingChunked = true;
request.Content = new StringContent("Hello World");
await SendRequest(listener, request);
}
public void BodyDelegate_ThrowsSync_ConnectionClosed()
{
bool callCancelled = false;
OwinHttpListener listener = CreateServer(
env =>
{
GetCallCancelled(env).Register(() => callCancelled = true);
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders.Add("Content-Length", new string[] { "10" });
var responseStream = env.Get <Stream>("owin.ResponseBody");
responseStream.WriteByte(0xFF);
throw new NotImplementedException();
},
HttpServerAddress);
try
{
// TODO: XUnit 2.0 adds support for Assert.Throws<...>(async () => await myTask);
// that way we can specify the correct exception type.
Assert.Throws <AggregateException>(() => SendGetRequest(listener, HttpClientAddress).Result);
}
finally
{
Assert.True(callCancelled);
}
}
public async Task Body_PostEchoRequest_Success()
{
bool callCancelled = false;
OwinHttpListener listener = CreateServer(
async env =>
{
GetCallCancelled(env).Register(() => callCancelled = true);
var requestHeaders = env.Get <IDictionary <string, string[]> >("owin.RequestHeaders");
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders.Add("Content-Length", requestHeaders["Content-Length"]);
var requestStream = env.Get <Stream>("owin.RequestBody");
var responseStream = env.Get <Stream>("owin.ResponseBody");
var buffer = new MemoryStream();
await requestStream.CopyToAsync(buffer, 1024);
buffer.Seek(0, SeekOrigin.Begin);
await buffer.CopyToAsync(responseStream, 1024);
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
string dataString = "Hello World";
HttpResponseMessage result = await client.PostAsync(HttpClientAddress, new StringContent(dataString));
result.EnsureSuccessStatusCode();
Assert.Equal(dataString.Length, result.Content.Headers.ContentLength.Value);
Assert.Equal(dataString, await result.Content.ReadAsStringAsync());
Assert.False(callCancelled);
}
}
public async Task Headers_CustomHeaders_PassedThrough()
{
OwinHttpListener listener = CreateServer(
env =>
{
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders.Add("Custom1", new string[] { "value1a", "value1b" });
responseHeaders.Add("Custom2", new string[] { "value2a, value2b" });
responseHeaders.Add("Custom3", new string[] { "value3a, value3b", "value3c" });
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpResponseMessage response = await client.GetAsync(HttpClientAddress);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(6, response.Headers.Count()); // Date, Chunked, Server
Assert.Equal(2, response.Headers.GetValues("Custom1").Count());
Assert.Equal("value1a", response.Headers.GetValues("Custom1").First());
Assert.Equal("value1b", response.Headers.GetValues("Custom1").Skip(1).First());
Assert.Equal(1, response.Headers.GetValues("Custom2").Count());
Assert.Equal("value2a, value2b", response.Headers.GetValues("Custom2").First());
Assert.Equal(2, response.Headers.GetValues("Custom3").Count());
Assert.Equal("value3a, value3b", response.Headers.GetValues("Custom3").First());
Assert.Equal("value3c", response.Headers.GetValues("Custom3").Skip(1).First());
}
}
public async Task OwinHttpListenerResponse_HeadRequestWithContentLength_Success()
{
OwinHttpListener listener = CreateServer(env =>
{
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
responseHeaders["Content-Length"] = new string[] { "10" };
return(TaskHelpers.Completed());
}, HttpServerAddress);
using (listener)
{
var client = new HttpClient();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Head, HttpClientAddress);
HttpResponseMessage response = await client.SendAsync(request);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("OK", response.ReasonPhrase);
Assert.Equal(2, response.Headers.Count());
Assert.False(response.Headers.TransferEncodingChunked.HasValue);
Assert.True(response.Headers.Date.HasValue);
Assert.Equal(1, response.Headers.Server.Count);
Assert.Equal(1, response.Content.Headers.Count()); // Content-Length
Assert.Equal(10, response.Content.Headers.ContentLength);
Assert.Equal(string.Empty, await response.Content.ReadAsStringAsync());
}
}
private static void FixCrashBug(OwinHttpListener owinHttpListener)
{
var httpListener = owinHttpListener.Listener;
var currentOutstandingAccepts = 0;
var currentOutstandingRequests = 0;
var owinHttpListenerType = owinHttpListener.GetType();
var owinHttpListenerOffloadStartNextRequestMethodInfo = owinHttpListenerType.GetMethod("OffloadStartNextRequest", DefaultBindingFlags);
var owinHttpListenerOffloadStartNextRequest = (Action)Delegate.CreateDelegate(typeof(Action), owinHttpListener, owinHttpListenerOffloadStartNextRequestMethodInfo);
var owinHttpListenerCanAcceptMoreRequestsPropertyInfo = owinHttpListener.GetType().GetProperty("CanAcceptMoreRequests", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new MissingMemberException("CanAcceptMoreRequests");
var owinHttpListenerProcessRequestAsyncMethodInfo = owinHttpListener.GetType().GetMethod("ProcessRequestAsync", BindingFlags.Instance | BindingFlags.NonPublic, null, new[] { typeof(HttpListenerContext) }, null);
var owinHttpListenerProcessRequestAsync = (Func <HttpListenerContext, Task>)Delegate.CreateDelegate(typeof(Func <HttpListenerContext, Task>), owinHttpListener, owinHttpListenerProcessRequestAsyncMethodInfo ?? throw new MissingMethodException("ProcessRequestAsync"));
var logHelperLogExceptionMethodInfo = LogHelperType.GetMethod("LogException", BindingFlags.NonPublic | BindingFlags.Static);
var logHelperLogException = (Action <LoggerType, string, Exception>)Delegate.CreateDelegate(typeof(Action <LoggerType, string, Exception>), null, logHelperLogExceptionMethodInfo ?? throw new MissingMethodException("LogException"));
LoggerType owinHttpListenerLogger = null;
var newStartNextRequestAsync = new Action(async() =>
{
if (owinHttpListenerLogger == null)
{
lock (LockObj)
{
owinHttpListenerLogger = (LoggerType)owinHttpListenerType
.GetField("_logger", DefaultBindingFlags)
?.GetValue(owinHttpListener);
}
}
while (httpListener.IsListening && (bool)owinHttpListenerCanAcceptMoreRequestsPropertyInfo.GetValue(owinHttpListener))
{
Interlocked.Increment(ref currentOutstandingAccepts);
HttpListenerContext context;
try
{
context = await httpListener.GetContextAsync();
if (IsEmptyPayloadAndContentLength(context))
{
Interlocked.Decrement(ref currentOutstandingAccepts);
owinHttpListenerOffloadStartNextRequest();
continue;
}
}
catch (Exception ex)
{
Interlocked.Decrement(ref currentOutstandingAccepts);
logHelperLogException(owinHttpListenerLogger, "Accept", ex);
continue;
}
Interlocked.Decrement(ref currentOutstandingAccepts);
Interlocked.Increment(ref currentOutstandingRequests);
owinHttpListenerOffloadStartNextRequest();
await owinHttpListenerProcessRequestAsync(context);
}
});
owinHttpListenerType
.GetField("_startNextRequestAsync", DefaultBindingFlags)
?.SetValue(owinHttpListener, newStartNextRequestAsync);
}
public async Task AppDelegate_ThrowsSync_500Error()
{
OwinHttpListener listener = CreateServer(_notImplemented, HttpServerAddress);
HttpResponseMessage response = await SendGetRequest(listener, HttpClientAddress);
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
Assert.Equal(0, response.Content.Headers.ContentLength.Value);
}
private async Task SendGetRequest(OwinHttpListener listener, string address)
{
using (listener)
{
var client = new HttpClient();
string result = await client.GetStringAsync(address);
}
}
public AutoTuneMiddleware(AppFunc next, OwinHttpListener server)
{
_next = next;
_server = server;
_server.SetRequestProcessingLimits((int)_currentMaxAccepts, _currentMaxRequests);
_timer = new Timer(TimerFired, null, TimeSpan.FromSeconds(0), TimeSpan.FromSeconds(0.1));
}
public async Task EndToEnd_GetRequest_Success()
{
OwinHttpListener listener = CreateServer(env => TaskHelpers.Completed(), HttpServerAddress);
HttpResponseMessage response = await SendGetRequest(listener, HttpClientAddress);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.Headers.ContentLength.Value);
}
public void OwinHttpListener_HttpsCreatedStartedStoppedDisposed_Success()
{
OwinHttpListener listener = CreateServer(_notImplemented, HttpsServerAddress);
using (listener)
{
listener.Stop();
}
}
private async Task SendRequest(OwinHttpListener listener, HttpRequestMessage request)
{
using (listener)
{
var client = new HttpClient();
HttpResponseMessage result = await client.SendAsync(request);
result.EnsureSuccessStatusCode();
}
}
public async Task SubProtocol_SelectLastSubProtocol_Success()
{
OwinHttpListener listener = CreateServer(env =>
{
var accept = (WebSocketAccept)env["websocket.Accept"];
Assert.NotNull(accept);
var requestHeaders = env.Get <IDictionary <string, string[]> >("owin.RequestHeaders");
var responseHeaders = env.Get <IDictionary <string, string[]> >("owin.ResponseHeaders");
// Select the last sub-protocol from the client.
string subProtocol = requestHeaders["Sec-WebSocket-Protocol"].Last().Split(',').Last().Trim();
responseHeaders["Sec-WebSocket-Protocol"] = new string[] { subProtocol + "A" };
accept(
new Dictionary <string, object>()
{
{ "websocket.SubProtocol", subProtocol }
},
async wsEnv =>
{
var sendAsync = wsEnv.Get <WebSocketSendAsync>("websocket.SendAsync");
var receiveAsync = wsEnv.Get <WebSocketReceiveAsync>("websocket.ReceiveAsync");
var closeAsync = wsEnv.Get <WebSocketCloseAsync>("websocket.CloseAsync");
var buffer = new ArraySegment <byte>(new byte[100]);
Tuple <int, bool, int> serverReceive = await receiveAsync(buffer, CancellationToken.None);
// Assume close received
await closeAsync((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
});
return(TaskHelpers.Completed());
},
HttpServerAddress);
using (listener)
{
using (var client = new ClientWebSocket())
{
client.Options.AddSubProtocol("protocol1");
client.Options.AddSubProtocol("protocol2");
await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None);
await client.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
var receiveBody = new byte[100];
WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment <byte>(receiveBody), CancellationToken.None);
Assert.Equal(WebSocketMessageType.Close, readResult.MessageType);
Assert.Equal("protocol2", client.SubProtocol);
}
}
}
public void Ctor_PathMissingEndSlash_Added()
{
OwinHttpListener listener = CreateServer(_notImplemented, new string[]
{
"http", "localhost", "8080", "/BadPathDoesntEndInSlash"
});
using (listener)
{
listener.Stop();
}
}
public async Task EndToEnd_EchoData_Success()
{
ManualResetEvent echoComplete = new ManualResetEvent(false);
OwinHttpListener listener = CreateServer(env =>
{
var accept = (WebSocketAccept)env["websocket.Accept"];
Assert.NotNull(accept);
accept(
null,
async wsEnv =>
{
var sendAsync = wsEnv.Get <WebSocketSendAsync>("websocket.SendAsync");
var receiveAsync = wsEnv.Get <WebSocketReceiveAsync>("websocket.ReceiveAsync");
var closeAsync = wsEnv.Get <WebSocketCloseAsync>("websocket.CloseAsync");
var buffer = new ArraySegment <byte>(new byte[100]);
Tuple <int, bool, int> serverReceive = await receiveAsync(buffer, CancellationToken.None);
await sendAsync(new ArraySegment <byte>(buffer.Array, 0, serverReceive.Item3),
serverReceive.Item1, serverReceive.Item2, CancellationToken.None);
Assert.True(echoComplete.WaitOne(100), "Echo incomplete");
await closeAsync((int)WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None);
});
return(Task.FromResult(0));
},
HttpServerAddress);
using (listener)
{
using (var client = new ClientWebSocket())
{
await client.ConnectAsync(new Uri(WsClientAddress), CancellationToken.None);
byte[] sendBody = Encoding.UTF8.GetBytes("Hello World");
await client.SendAsync(new ArraySegment <byte>(sendBody), WebSocketMessageType.Text, true, CancellationToken.None);
var receiveBody = new byte[100];
WebSocketReceiveResult readResult = await client.ReceiveAsync(new ArraySegment <byte>(receiveBody), CancellationToken.None);
echoComplete.Set();
Assert.Equal(WebSocketMessageType.Text, readResult.MessageType);
Assert.True(readResult.EndOfMessage);
Assert.Equal(sendBody.Length, readResult.Count);
Assert.Equal("Hello World", Encoding.UTF8.GetString(receiveBody, 0, readResult.Count));
}
}
}
public async Task EndToEnd_SingleThreadedTwoGetRequests_Success()
{
OwinHttpListener listener = CreateServer(env => TaskHelpers.Completed(), HttpServerAddress);
using (listener)
{
var client = new HttpClient();
string result = await client.GetStringAsync(HttpClientAddress);
Assert.Equal(string.Empty, result);
result = await client.GetStringAsync(HttpClientAddress);
Assert.Equal(string.Empty, result);
}
}
public async Task EndToEnd_HttpsGetRequestNoClientCert_Success()
{
OwinHttpListener listener = CreateServer(
env =>
{
object obj;
Assert.False(env.TryGetValue("owin.ClientCertificate", out obj));
return(TaskHelpers.Completed());
},
HttpsServerAddress);
HttpResponseMessage response = await SendGetRequest(listener, HttpsClientAddress, null);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.Headers.ContentLength.Value);
}
private Task<HttpResponseMessage> SendGetRequest(OwinHttpListener listener, string address)
{
return SendGetRequest(listener, address, null);
}
public async Task PathAndPathBase_CorrectlySeperated(string clientString, string serverBasePath,
string expectedBasePath, string expectedPath, string expectedQuery)
{
var fallbackAddress = new string[4];
HttpServerAddress.CopyTo(fallbackAddress, 0);
fallbackAddress[3] = "/";
var serverAddress = new string[4];
HttpServerAddress.CopyTo(serverAddress, 0);
serverAddress[3] = serverBasePath;
clientString = "http://localhost:8080" + clientString;
using (var wrapper = new OwinHttpListener())
{
wrapper.Start(wrapper.Listener, env =>
{
Assert.Equal(expectedBasePath, (string)env["owin.RequestPathBase"]);
Assert.Equal(expectedPath, (string)env["owin.RequestPath"]);
Assert.Equal(expectedQuery, (string)env["owin.RequestQueryString"]);
return TaskHelpers.Completed();
}, CreateAddresses(fallbackAddress, serverAddress), null);
using (var client = new HttpClient())
{
HttpResponseMessage result = await client.GetAsync(clientString);
Assert.Equal(HttpStatusCode.OK, result.StatusCode);
}
}
}
private Task<HttpResponseMessage> SendGetRequest(OwinHttpListener listener, string address)
{
return SendGetRequest(listener, address, ClientCertificateOption.Automatic);
}
private async Task<HttpResponseMessage> SendGetRequest(OwinHttpListener listener, string address, ClientCertificateOption certOptions)
{
using (listener)
{
var handler = new WebRequestHandler();
// Ignore server cert errors.
handler.ServerCertificateValidationCallback = (a, b, c, d) => true;
handler.ClientCertificateOptions = certOptions;
var client = new HttpClient(handler);
return await client.GetAsync(address);
}
}
private bool PropertiesTrySetValue(string key, object value)
{
switch (key.Length)
{
case 12:
if (string.Equals(key, "owin.Version", StringComparison.Ordinal))
{
OwinVersion = (string)value;
return true;
}
if (string.Equals(key, "host.AppName", StringComparison.Ordinal))
{
HostAppName = (string)value;
return true;
}
if (string.Equals(key, "host.AppMode", StringComparison.Ordinal))
{
HostAppMode = (string)value;
return true;
}
break;
case 18:
if (string.Equals(key, "owin.CallCancelled", StringComparison.Ordinal))
{
CallCancelled = (CancellationToken)value;
return true;
}
if (string.Equals(key, "owin.RequestMethod", StringComparison.Ordinal))
{
RequestMethod = (string)value;
return true;
}
if (string.Equals(key, "owin.RequestScheme", StringComparison.Ordinal))
{
RequestScheme = (string)value;
return true;
}
break;
case 20:
if (string.Equals(key, "owin.RequestProtocol", StringComparison.Ordinal))
{
RequestProtocol = (string)value;
return true;
}
if (string.Equals(key, "owin.RequestPathBase", StringComparison.Ordinal))
{
RequestPathBase = (string)value;
return true;
}
if (string.Equals(key, "owin.ResponseHeaders", StringComparison.Ordinal))
{
ResponseHeaders = (IDictionary<string, string[]>)value;
return true;
}
break;
case 16:
if (string.Equals(key, "owin.RequestPath", StringComparison.Ordinal))
{
RequestPath = (string)value;
return true;
}
if (string.Equals(key, "owin.RequestBody", StringComparison.Ordinal))
{
RequestBody = (Stream)value;
return true;
}
if (string.Equals(key, "host.TraceOutput", StringComparison.Ordinal))
{
HostTraceOutput = (TextWriter)value;
return true;
}
if (string.Equals(key, "server.LocalPort", StringComparison.Ordinal))
{
ServerLocalPort = (string)value;
return true;
}
if (string.Equals(key, "websocket.Accept", StringComparison.Ordinal))
{
WebSocketAccept = (WebSocketAccept)value;
return true;
}
break;
case 23:
if (string.Equals(key, "owin.RequestQueryString", StringComparison.Ordinal))
{
RequestQueryString = (string)value;
return true;
}
if (string.Equals(key, "owin.ResponseStatusCode", StringComparison.Ordinal))
{
ResponseStatusCode = (int)value;
return true;
}
if (string.Equals(key, "server.OnSendingHeaders", StringComparison.Ordinal))
{
OnSendingHeaders = (Action<Action<object>, object>)value;
return true;
}
if (string.Equals(key, "ssl.LoadClientCertAsync", StringComparison.Ordinal))
{
LoadClientCert = (Func<Task>)value;
return true;
}
break;
case 19:
if (string.Equals(key, "owin.RequestHeaders", StringComparison.Ordinal))
{
RequestHeaders = (IDictionary<string, string[]>)value;
return true;
}
if (string.Equals(key, "host.OnAppDisposing", StringComparison.Ordinal))
{
OnAppDisposing = (CancellationToken)value;
return true;
}
if (string.Equals(key, "server.Capabilities", StringComparison.Ordinal))
{
ServerCapabilities = (IDictionary<string, object>)value;
return true;
}
break;
case 25:
if (string.Equals(key, "owin.ResponseReasonPhrase", StringComparison.Ordinal))
{
ResponseReasonPhrase = (string)value;
return true;
}
break;
case 17:
if (string.Equals(key, "owin.ResponseBody", StringComparison.Ordinal))
{
ResponseBody = (Stream)value;
return true;
}
if (string.Equals(key, "server.RemotePort", StringComparison.Ordinal))
{
ServerRemotePort = (string)value;
return true;
}
break;
case 11:
if (string.Equals(key, "server.User", StringComparison.Ordinal))
{
ServerUser = (IPrincipal)value;
return true;
}
break;
case 22:
if (string.Equals(key, "server.RemoteIpAddress", StringComparison.Ordinal))
{
ServerRemoteIpAddress = (string)value;
return true;
}
break;
case 21:
if (string.Equals(key, "server.LocalIpAddress", StringComparison.Ordinal))
{
ServerLocalIpAddress = (string)value;
return true;
}
if (string.Equals(key, "ssl.ClientCertificate", StringComparison.Ordinal))
{
ClientCert = (X509Certificate)value;
return true;
}
if (string.Equals(key, "Mono.Net.HttpListener", StringComparison.Ordinal))
{
Listener = (Mono.Net.HttpListener)value;
return true;
}
break;
case 14:
if (string.Equals(key, "server.IsLocal", StringComparison.Ordinal))
{
ServerIsLocal = (bool)value;
return true;
}
break;
case 27:
if (string.Equals(key, "ssl.ClientCertificateErrors", StringComparison.Ordinal))
{
ClientCertErrors = (Exception)value;
return true;
}
break;
case 28:
if (string.Equals(key, "Mono.Net.HttpListenerContext", StringComparison.Ordinal))
{
RequestContext = (HttpListenerContext)value;
return true;
}
break;
case 49:
if (string.Equals(key, "Microsoft.Owin.Host.HttpListener.OwinHttpListener", StringComparison.Ordinal))
{
OwinHttpListener = (OwinHttpListener)value;
return true;
}
break;
}
return false;
}
private bool PropertiesTryRemove(string key)
{
switch (key.Length)
{
case 12:
if (((_flag0 & 0x1u) != 0) && string.Equals(key, "owin.Version", StringComparison.Ordinal))
{
_flag0 &= ~0x1u;
_OwinVersion = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x8000u) != 0) && string.Equals(key, "host.AppName", StringComparison.Ordinal))
{
_flag0 &= ~0x8000u;
_HostAppName = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x10000u) != 0) && string.Equals(key, "host.AppMode", StringComparison.Ordinal))
{
_flag0 &= ~0x10000u;
_HostAppMode = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 18:
if (((_flag0 & 0x2u) != 0) && string.Equals(key, "owin.CallCancelled", StringComparison.Ordinal))
{
_initFlag0 &= ~0x2u;
_flag0 &= ~0x2u;
_CallCancelled = default(CancellationToken);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x8u) != 0) && string.Equals(key, "owin.RequestMethod", StringComparison.Ordinal))
{
_flag0 &= ~0x8u;
_RequestMethod = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x10u) != 0) && string.Equals(key, "owin.RequestScheme", StringComparison.Ordinal))
{
_flag0 &= ~0x10u;
_RequestScheme = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 20:
if (((_flag0 & 0x4u) != 0) && string.Equals(key, "owin.RequestProtocol", StringComparison.Ordinal))
{
_flag0 &= ~0x4u;
_RequestProtocol = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x20u) != 0) && string.Equals(key, "owin.RequestPathBase", StringComparison.Ordinal))
{
_flag0 &= ~0x20u;
_RequestPathBase = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x1000u) != 0) && string.Equals(key, "owin.ResponseHeaders", StringComparison.Ordinal))
{
_flag0 &= ~0x1000u;
_ResponseHeaders = default(IDictionary<string, string[]>);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 16:
if (((_flag0 & 0x40u) != 0) && string.Equals(key, "owin.RequestPath", StringComparison.Ordinal))
{
_flag0 &= ~0x40u;
_RequestPath = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x200u) != 0) && string.Equals(key, "owin.RequestBody", StringComparison.Ordinal))
{
_initFlag0 &= ~0x200u;
_flag0 &= ~0x200u;
_RequestBody = default(Stream);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x4000u) != 0) && string.Equals(key, "host.TraceOutput", StringComparison.Ordinal))
{
_flag0 &= ~0x4000u;
_HostTraceOutput = default(TextWriter);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x1000000u) != 0) && string.Equals(key, "server.LocalPort", StringComparison.Ordinal))
{
_initFlag0 &= ~0x1000000u;
_flag0 &= ~0x1000000u;
_ServerLocalPort = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x20000000u) != 0) && string.Equals(key, "websocket.Accept", StringComparison.Ordinal))
{
_initFlag0 &= ~0x20000000u;
_flag0 &= ~0x20000000u;
_WebSocketAccept = default(WebSocketAccept);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 23:
if (((_flag0 & 0x80u) != 0) && string.Equals(key, "owin.RequestQueryString", StringComparison.Ordinal))
{
_flag0 &= ~0x80u;
_RequestQueryString = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x400u) != 0) && string.Equals(key, "owin.ResponseStatusCode", StringComparison.Ordinal))
{
_flag0 &= ~0x400u;
_ResponseStatusCode = default(int);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x80000u) != 0) && string.Equals(key, "server.OnSendingHeaders", StringComparison.Ordinal))
{
_flag0 &= ~0x80000u;
_OnSendingHeaders = default(Action<Action<object>, object>);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x10000000u) != 0) && string.Equals(key, "ssl.LoadClientCertAsync", StringComparison.Ordinal))
{
_flag0 &= ~0x10000000u;
_LoadClientCert = default(Func<Task>);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 19:
if (((_flag0 & 0x100u) != 0) && string.Equals(key, "owin.RequestHeaders", StringComparison.Ordinal))
{
_flag0 &= ~0x100u;
_RequestHeaders = default(IDictionary<string, string[]>);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x20000u) != 0) && string.Equals(key, "host.OnAppDisposing", StringComparison.Ordinal))
{
_flag0 &= ~0x20000u;
_OnAppDisposing = default(CancellationToken);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x100000u) != 0) && string.Equals(key, "server.Capabilities", StringComparison.Ordinal))
{
_flag0 &= ~0x100000u;
_ServerCapabilities = default(IDictionary<string, object>);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 25:
if (((_flag0 & 0x800u) != 0) && string.Equals(key, "owin.ResponseReasonPhrase", StringComparison.Ordinal))
{
_flag0 &= ~0x800u;
_ResponseReasonPhrase = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 17:
if (((_flag0 & 0x2000u) != 0) && string.Equals(key, "owin.ResponseBody", StringComparison.Ordinal))
{
_flag0 &= ~0x2000u;
_ResponseBody = default(Stream);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x400000u) != 0) && string.Equals(key, "server.RemotePort", StringComparison.Ordinal))
{
_initFlag0 &= ~0x400000u;
_flag0 &= ~0x400000u;
_ServerRemotePort = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 11:
if (((_flag0 & 0x40000u) != 0) && string.Equals(key, "server.User", StringComparison.Ordinal))
{
_flag0 &= ~0x40000u;
_ServerUser = default(IPrincipal);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 22:
if (((_flag0 & 0x200000u) != 0) && string.Equals(key, "server.RemoteIpAddress", StringComparison.Ordinal))
{
_initFlag0 &= ~0x200000u;
_flag0 &= ~0x200000u;
_ServerRemoteIpAddress = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 21:
if (((_flag0 & 0x800000u) != 0) && string.Equals(key, "server.LocalIpAddress", StringComparison.Ordinal))
{
_initFlag0 &= ~0x800000u;
_flag0 &= ~0x800000u;
_ServerLocalIpAddress = default(string);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x4000000u) != 0) && string.Equals(key, "ssl.ClientCertificate", StringComparison.Ordinal))
{
_initFlag0 &= ~0x4000000u;
_flag0 &= ~0x4000000u;
_ClientCert = default(X509Certificate);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
if (((_flag0 & 0x80000000u) != 0) && string.Equals(key, "Mono.Net.HttpListener", StringComparison.Ordinal))
{
_flag0 &= ~0x80000000u;
_Listener = default(Mono.Net.HttpListener);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 14:
if (((_flag0 & 0x2000000u) != 0) && string.Equals(key, "server.IsLocal", StringComparison.Ordinal))
{
_initFlag0 &= ~0x2000000u;
_flag0 &= ~0x2000000u;
_ServerIsLocal = default(bool);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 27:
if (((_flag0 & 0x8000000u) != 0) && string.Equals(key, "ssl.ClientCertificateErrors", StringComparison.Ordinal))
{
_initFlag0 &= ~0x8000000u;
_flag0 &= ~0x8000000u;
_ClientCertErrors = default(Exception);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 28:
if (((_flag0 & 0x40000000u) != 0) && string.Equals(key, "Mono.Net.HttpListenerContext", StringComparison.Ordinal))
{
_flag0 &= ~0x40000000u;
_RequestContext = default(HttpListenerContext);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
case 49:
if (((_flag1 & 0x1u) != 0) && string.Equals(key, "Microsoft.Owin.Host.HttpListener.OwinHttpListener", StringComparison.Ordinal))
{
_flag1 &= ~0x1u;
_OwinHttpListener = default(OwinHttpListener);
// This can return true incorrectly for values that delayed initialization may determine are not actually present.
return true;
}
break;
}
return false;
}
private OwinHttpListener CreateServer(Func<IDictionary<string, object>, Task> app, string[] addressParts)
{
var wrapper = new OwinHttpListener();
wrapper.Start(wrapper.Listener, app, CreateAddress(addressParts), null);
return wrapper;
}
private async Task SendGetRequest(OwinHttpListener listener, string address)
{
using (listener)
{
var client = new HttpClient();
string result = await client.GetStringAsync(address);
}
}
private async Task SendRequest(OwinHttpListener listener, HttpRequestMessage request)
{
using (listener)
{
var client = new HttpClient();
HttpResponseMessage result = await client.SendAsync(request);
result.EnsureSuccessStatusCode();
}
}
private OwinHttpListener CreateServer(AppFunc app, string[] addressParts)
{
var wrapper = new OwinHttpListener();
wrapper.Start(wrapper.Listener, app, CreateAddress(addressParts), null, null);
return wrapper;
}
