static ISslStreamProvider GetSslStreamProvider(TestContext ctx, HttpServerFlags serverFlags)
{
var factory = DependencyInjector.Get <ConnectionProviderFactory> ();
ConnectionProvider provider;
ConnectionTestFlags explicitFlags;
ConnectionProviderType providerType;
if (ctx.TryGetParameter(out providerType))
{
provider = factory.GetProvider(providerType);
}
else if (ctx.TryGetParameter(out explicitFlags))
{
explicitFlags |= ConnectionTestFlags.RequireSslStream;
var filter = ConnectionProviderFilter.CreateSimpleFilter(explicitFlags);
provider = filter.GetDefaultServer(ctx, null);
}
else if ((serverFlags & HttpListenerSsl) == HttpListenerSsl)
{
explicitFlags = ConnectionTestFlags.RequireHttpListener;
var filter = ConnectionProviderFilter.CreateSimpleFilter(explicitFlags);
provider = filter.GetDefaultServer(ctx, null);
}
else
{
return(factory.DefaultSslStreamProvider);
}
ctx.Assert(provider, Is.Not.Null, "Failed to resolve ConnectionProvider");
ctx.Assert(provider.SupportsSslStreams, "Seleced ConnectionProvider `{0}' does not support SSL.", provider);
return(provider.SslStreamProvider);
}
public HttpServerProvider(
string identifier, HttpServerFlags serverFlags,
ISslStreamProvider provider)
{
Value = identifier;
ServerFlags = serverFlags;
SslStreamProvider = provider;
}
static void CheckConnectionFlags(ref ConnectionTestFlags flags, HttpServerFlags serverFlags)
{
var sslListenerFlags = HttpServerFlags.HttpListener | HttpServerFlags.SSL;
if ((serverFlags & sslListenerFlags) == sslListenerFlags)
{
flags |= ConnectionTestFlags.RequireMonoServer | ConnectionTestFlags.RequireHttpListener;
}
}
public HttpValidationTestRunner(IPortableEndPoint endpoint, HttpValidationTestParameters parameters,
ConnectionTestProvider provider, Uri uri, HttpServerFlags flags)
{
Parameters = parameters;
Provider = provider;
ServerFlags = flags;
Uri = uri;
Server = new BuiltinHttpServer(uri, endpoint, ServerFlags, parameters, null);
ME = $"{GetType ().Name}({EffectiveType})";
}
public HttpsTestRunner(IPortableEndPoint endpoint, HttpsTestParameters parameters,
ConnectionTestProvider provider, Uri uri, HttpServerFlags flags)
: base(endpoint, parameters)
{
Provider = provider;
ServerFlags = flags;
Uri = uri;
Server = new BuiltinHttpServer(uri, endpoint, flags, parameters, null)
{
Delegate = this
};
}
bool GetParameters(TestContext ctx, HttpServerFlags flags, out ConnectionParameters parameters)
{
if ((flags & HttpServerFlags.SSL) == 0)
{
parameters = null;
return(false);
}
var certificate = ResourceManager.SelfSignedServerCertificate;
parameters = new ConnectionParameters("http", certificate);
return(true);
}
static HttpServerFlags GetFlags(HttpServerFlags flags, HttpServer target, AuthenticationType proxyAuth)
{
flags |= HttpServerFlags.Proxy;
if (target.UseSSL)
{
flags |= HttpServerFlags.ProxySSL;
}
if (proxyAuth != AuthenticationType.None)
{
flags |= HttpServerFlags.ProxyAuthentication;
}
return(flags);
}
HttpServerFlags GetServerFlags(TestContext ctx)
{
HttpServerFlags flags = serverFlags | HttpServerFlags.SSL;
bool reuseConnection;
if (ctx.TryGetParameter <bool> (out reuseConnection, "ReuseConnection") && reuseConnection)
{
flags |= HttpServerFlags.ReuseConnection;
}
return(flags);
}
public HttpServer(IPortableEndPoint listenAddress, HttpServerFlags flags,
ConnectionParameters parameters, ISslStreamProvider sslStreamProvider)
{
ListenAddress = listenAddress;
Flags = flags;
Parameters = parameters;
SslStreamProvider = sslStreamProvider;
if (Parameters != null)
{
Flags |= HttpServerFlags.SSL;
}
if ((Flags & HttpServerFlags.NoSSL) != 0)
{
Flags &= ~HttpServerFlags.SSL;
}
if ((Flags & HttpServerFlags.SSL) != 0)
{
if (SslStreamProvider == null)
{
var factory = DependencyInjector.Get <ConnectionProviderFactory> ();
SslStreamProvider = factory.DefaultSslStreamProvider;
}
}
else
{
SslStreamProvider = null;
}
var description = FormatFlags(Flags);
if (!string.IsNullOrEmpty(description))
{
description = ": " + description;
}
var identifier = parameters?.Identifier;
if (identifier != null)
{
identifier = ": " + identifier;
}
ME = $"[{GetType ().Name}:{ID}{identifier}{description}]";
}
public IEnumerable <HttpServerProvider> GetProviders(TestContext ctx)
{
HttpServerFlags serverFlags = HttpServerFlags.None;
if (UsingHttpListener)
{
serverFlags |= HttpServerFlags.HttpListener;
}
if (IsMartinTest)
{
yield return(new HttpServerProvider("https", serverFlags, null));
yield break;
}
if (!RequireSsl)
{
serverFlags |= HttpServerFlags.NoSSL;
yield return(new HttpServerProvider("http", serverFlags, null));
}
if (!UsingSsl)
{
yield break;
}
var supportedProviders = GetSupportedProviders(ctx);
if (supportedProviders.Count() == 0)
{
ctx.AssertFail("Could not find any supported HttpServerProvider.");
}
serverFlags |= HttpServerFlags.SSL;
foreach (var provider in supportedProviders)
{
yield return(new HttpServerProvider(
$"https:{provider.Name}", serverFlags,
provider.SslStreamProvider));
}
}
public static IEnumerable <PostHandler> GetPostTests(HttpServerFlags flags)
{
if ((flags & HttpServerFlags.HttpListener) == 0)
{
yield return(new PostHandler("No body"));
}
yield return(new PostHandler("Empty body", StringContent.Empty));
yield return(new PostHandler("Normal post", HttpContent.HelloWorld));
yield return(new PostHandler("Content-Length", HttpContent.HelloWorld, TransferMode.ContentLength));
yield return(new PostHandler("Chunked", HttpContent.HelloChunked, TransferMode.Chunked));
yield return(new PostHandler("Explicit length and empty body", StringContent.Empty, TransferMode.ContentLength));
yield return(new PostHandler("Explicit length and no body", null, TransferMode.ContentLength));
yield return(new PostHandler("Bug #41206", new RandomContent(102400)));
yield return(new PostHandler("Bug #41206 odd size", new RandomContent(102431)));
}
public HttpServer(IPortableEndPoint listenAddress, HttpServerFlags flags,
ConnectionParameters parameters, ISslStreamProvider sslStreamProvider)
{
ListenAddress = listenAddress;
Flags = flags;
Parameters = parameters;
SslStreamProvider = sslStreamProvider;
if (Parameters != null)
{
Flags |= HttpServerFlags.SSL;
}
if ((Flags & HttpServerFlags.SSL) != 0)
{
if (SslStreamProvider == null)
{
var factory = DependencyInjector.Get <ConnectionProviderFactory> ();
SslStreamProvider = factory.DefaultSslStreamProvider;
}
}
}
static string FormatFlags(HttpServerFlags flags)
{
var sb = new StringBuilder();
Append("shared", HttpServerFlags.ReuseConnection);
Append("ssl", HttpServerFlags.SSL);
Append("proxy", HttpServerFlags.Proxy);
Append("ssl-proxy", HttpServerFlags.ProxySSL);
Append("proxy-auth", HttpServerFlags.ProxyAuthentication);
return(sb.ToString());
void Append(string name, HttpServerFlags flag)
{
if ((flags & flag) == 0)
{
return;
}
if (sb.Length > 0)
{
sb.Append(",");
}
sb.Append(name);
}
}
public BuiltinHttpServer(Uri uri, IPortableEndPoint listenAddress, HttpServerFlags flags,
ConnectionParameters parameters, ISslStreamProvider sslStreamProvider)
: base(listenAddress, flags | HttpServerFlags.SSL, parameters, sslStreamProvider)
{
Uri = uri;
}
public BuiltinHttpServer(IPortableEndPoint clientEndPoint, IPortableEndPoint listenAddress, HttpServerFlags flags,
ConnectionParameters parameters, ISslStreamProvider sslStreamProvider)
: base(listenAddress, flags, parameters, sslStreamProvider)
{
Uri = new Uri(string.Format("http{0}://{1}:{2}/", SslStreamProvider != null ? "s" : "", clientEndPoint.Address, clientEndPoint.Port));
}
public BuiltinProxyServer(HttpServer target, IPortableEndPoint listenAddress, HttpServerFlags flags)
: base(listenAddress, flags | HttpServerFlags.Proxy, null, null)
{
Target = target;
Uri = new Uri(string.Format("http://{0}:{1}/", ListenAddress.Address, ListenAddress.Port));
}
public HttpServerAttribute(HttpServerFlags serverFlags)
: base(null, TestFlags.Hidden)
{
ExplicitServerFlags = serverFlags;
}
public static IEnumerable <Handler> GetParameters(TestContext ctx, string filter, HttpServerFlags flags)
{
switch (filter)
{
case null:
var list = new List <Handler> ();
list.Add(new HelloWorldHandler("hello world"));
list.AddRange(GetPostTests(flags));
list.AddRange(GetDeleteTests());
list.AddRange(GetRecentlyFixed());
return(list);
case "post":
return(GetPostTests(flags));
case "delete":
return(GetDeleteTests());
case "chunked":
return(GetChunkedTests());
case "recently-fixed":
return(GetRecentlyFixed());
default:
throw ctx.AssertFail("Invalid TestPost filter `{0}'.", filter);
}
}
public BuiltinProxyServer(HttpServer target, IPortableEndPoint listenAddress, HttpServerFlags flags,
AuthenticationType proxyAuth = AuthenticationType.None)
: base(listenAddress, GetFlags(flags, target, proxyAuth), null, null)
{
Target = target;
AuthenticationType = proxyAuth;
Uri = new Uri(string.Format("http://{0}:{1}/", ListenAddress.Address, ListenAddress.Port));
}
public HttpServerFlagsAttribute(HttpServerFlags flags)
{
Flags = flags;
}
public HttpsTestRunnerAttribute(HttpServerFlags serverFlags = HttpServerFlags.None)
: base(typeof(HttpsTestRunnerAttribute))
{
this.serverFlags = serverFlags;
}
