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))); }