public HttpStressTestRunner CreateInstance(TestContext ctx)
{
var provider = ctx.GetParameter <ConnectionTestProvider> ();
var parameters = ctx.GetParameter <HttpStressTestParameters> ();
ProtocolVersions protocolVersion;
if (ctx.TryGetParameter <ProtocolVersions> (out protocolVersion))
{
parameters.ProtocolVersion = protocolVersion;
}
IPortableEndPoint serverEndPoint;
if (parameters.ListenAddress != null)
{
serverEndPoint = parameters.ListenAddress;
}
else if (parameters.EndPoint != null)
{
serverEndPoint = parameters.EndPoint;
}
else
{
serverEndPoint = ConnectionTestHelper.GetEndPoint();
}
if (parameters.EndPoint == null)
{
parameters.EndPoint = serverEndPoint;
}
if (parameters.ListenAddress == null)
{
parameters.ListenAddress = serverEndPoint;
}
var flags = ServerFlags | HttpServerFlags.SSL;
bool reuseConnection;
if (ctx.TryGetParameter <bool> (out reuseConnection, "ReuseConnection") && reuseConnection)
{
flags |= HttpServerFlags.ReuseConnection;
}
Uri uri;
if (parameters.TargetHost == null)
{
parameters.TargetHost = parameters.EndPoint.HostName;
uri = new Uri(string.Format("https://{0}:{1}/", parameters.EndPoint.Address, parameters.EndPoint.Port));
}
else
{
uri = new Uri(string.Format("https://{0}/", parameters.TargetHost));
}
return(new HttpStressTestRunner(parameters.EndPoint, parameters, provider, uri, flags));
}
public IEnumerable <ClientAndServerProvider> GetSupportedProviders(TestContext ctx, string filter)
{
string clientFilter, serverFilter;
if (filter == null)
{
clientFilter = serverFilter = null;
}
else
{
int pos = filter.IndexOf(':');
if (pos < 0)
{
clientFilter = serverFilter = filter;
}
else
{
clientFilter = filter.Substring(0, pos);
serverFilter = filter.Substring(pos + 1);
}
}
var factory = DependencyInjector.Get <ConnectionProviderFactory> ();
var clientProviders = factory.GetProviders(p => IsClientSupported(ctx, p, clientFilter));
var serverProviders = factory.GetProviders(p => IsServerSupported(ctx, p, serverFilter));
return(ConnectionTestHelper.Join(clientProviders, serverProviders, (c, s) => {
return Create(c, s);
}));
}
public void SqlQueryableContext_Simple()
{
// Prepare test data
DbConnection connection = ConnectionTestHelper.CreatePopulatedConnection();
TableExpression expression = new TableExpression("Student", "Alias", new string[] { "Id", "FirstName", "LastName" });
SqlQueryVisitor visitor = new SqlQueryVisitor();
// Perform test operation
Record[] records = SqlQueryableContext
.ExecuteQuery(connection, expression, visitor)
.ToArray();
// Check the test result
Assert.AreEqual(ConnectionTestHelper.CountStudents, records.Length);
foreach (Record record in records)
{
Assert.AreEqual(1, record.Count);
RecordItem item = record["Alias"];
Assert.AreEqual(3, item.Count);
Assert.IsTrue(item.ContainsKey("Id"));
Assert.IsTrue(item.ContainsKey("FirstName"));
Assert.IsTrue(item.ContainsKey("LastName"));
}
}
public IEnumerable <ClientAndServerProvider> GetSupportedProviders(TestContext ctx, string filter)
{
string clientFilter, serverFilter;
if (filter == null)
{
clientFilter = serverFilter = null;
}
else
{
int pos = filter.IndexOf(':');
if (pos < 0)
{
clientFilter = serverFilter = filter;
}
else
{
clientFilter = filter.Substring(0, pos);
serverFilter = filter.Substring(pos + 1);
}
}
var factory = DependencyInjector.Get <ConnectionProviderFactory> ();
var providers = factory.GetProviders(p => IsSupported(p)).ToList();
if (providers.Count == 0)
{
return(new ClientAndServerProvider[0]);
}
var supportedClientProviders = providers.Where(p => IsClientSupported(p)).ToList();
var supportedServerProviders = providers.Where(p => IsServerSupported(p)).ToList();
if (supportedClientProviders.Count == 0 || supportedServerProviders.Count == 0)
{
return(new ClientAndServerProvider[0]);
}
var filteredClientProviders = supportedClientProviders.Where(p => IsSupported(ctx, p, clientFilter)).ToList();
var filteredServerProviders = supportedServerProviders.Where(p => IsSupported(ctx, p, serverFilter)).ToList();
if (filter != null)
{
if (filteredClientProviders.Count == 0)
{
ctx.LogMessage($"WARNING: No TLS Provider matches client filter '{clientFilter}'");
}
if (filteredServerProviders.Count == 0)
{
ctx.LogMessage($"WARNING: No TLS Provider matches server filter '{serverFilter}'");
}
}
return(ConnectionTestHelper.Join(filteredClientProviders, filteredServerProviders, (c, s) => {
return Create(c, s);
}));
}
public void QueryHelper_SelectRecordItems_Table_KeyNotFoundException()
{
// Prepare the test data
DbConnection connection = ConnectionTestHelper.CreatePopulatedConnection();
SqlQueryable query = new SqlQueryable(connection, "Course", new string[] { "Id", "Name" });
// Perform the test operation
query
.SelectRecordItems("NotATable")
.ToArray();
}
public void SqlQueryableContext_InvalidOperationException()
{
// Prepare test data
DbConnection connection = ConnectionTestHelper.CreatePopulatedConnection();
TableExpression expression = new TableExpression("Student", "Alias", new string[] { "Id", "FirstName", "LastName" });
SqlQueryVisitor visitor = new SqlQueryVisitor();
// Perform the test operation
connection.Close();
SqlQueryableContext.ExecuteQuery(connection, expression, visitor);
}
public HttpServer CreateInstance(TestContext ctx)
{
var endpoint = ConnectionTestHelper.GetEndPoint();
ConnectionParameters parameters;
ISslStreamProvider sslStreamProvider = null;
var flags = GetServerFlags(ctx);
if (GetParameters(ctx, flags, out parameters))
{
sslStreamProvider = GetSslStreamProvider(ctx, flags);
}
return(new BuiltinHttpServer(endpoint, endpoint, flags, parameters, sslStreamProvider));
}
public InstrumentationTestRunner(HttpServerProvider provider, string identifier)
{
Provider = provider;
ServerFlags = provider.ServerFlags | HttpServerFlags.InstrumentationListener;
ME = $"{GetType ().Name}({identifier})";
var endPoint = ConnectionTestHelper.GetEndPoint();
var proto = (ServerFlags & HttpServerFlags.NoSSL) != 0 ? "http" : "https";
Uri = new Uri($"{proto}://{endPoint.Address}:{endPoint.Port}/");
var parameters = GetParameters(identifier);
Server = new BuiltinHttpServer(
Uri, endPoint, ServerFlags, parameters,
provider.SslStreamProvider);
}
public void QueryHelper_SelectRecordItems_Table()
{
// Prepare the test data
DbConnection connection = ConnectionTestHelper.CreatePopulatedConnection();
SqlQueryable query = new SqlQueryable(connection, "Course", new string[] { "Id", "Name" });
// Perform the test operation
RecordItem[] items = query
.SelectRecordItems("Course")
.ToArray();
// Check the test result
Assert.AreEqual(ConnectionTestHelper.CountCourses, items.Length);
foreach (RecordItem item in items)
{
Assert.IsTrue(item.ContainsKey("Id"));
Assert.IsTrue(item.ContainsKey("Name"));
Assert.IsTrue(typeof(long).IsAssignableFrom(item["Id"].GetType()));
Assert.IsInstanceOfType(item["Name"], typeof(string));
}
}
public RenegotiationInstrumentTestRunner CreateInstance(TestContext ctx)
{
return(ConnectionTestHelper.CreateTestRunner <InstrumentationConnectionProvider, RenegotiationInstrumentParameters, RenegotiationInstrumentTestRunner> (
ctx, (s, c, p, a) => CreateInstance(ctx, s, c, p, a)));
}
public RenegotiationTestRunner CreateInstance(TestContext ctx)
{
return(ConnectionTestHelper.CreateTestRunner <ConnectionTestProvider, RenegotiationTestParameters, RenegotiationTestRunner> (
ctx, (s, c, t, p) => new RenegotiationTestRunner(s, c, t, p)));
}
public SimpleConnectionTestRunner CreateInstance(TestContext ctx)
{
return(ConnectionTestHelper.CreateTestRunner <MonoConnectionTestProvider, SimpleConnectionParameters, SimpleConnectionTestRunner> (
ctx, (s, c, p, a) => new SimpleConnectionTestRunner(s, c, p, a)));
}
public SslStreamTestRunner CreateInstance(TestContext ctx)
{
return(ConnectionTestHelper.CreateTestRunner <ConnectionTestProvider, SslStreamTestParameters, SslStreamTestRunner> (
ctx, (s, c, t, p) => new SslStreamTestRunner(s, c, t, p)));
}
public SignatureInstrumentTestRunner CreateInstance(TestContext ctx)
{
return(ConnectionTestHelper.CreateTestRunner <InstrumentationConnectionProvider, SignatureInstrumentParameters, SignatureInstrumentTestRunner> (
ctx, (s, c, p, a) => new SignatureInstrumentTestRunner(s, c, p, a)));
}
