HTTPServerTest.cpp File Reference

#include <proxygen/httpserver/HTTPServer.h>
#include <boost/thread.hpp>
#include <folly/FileUtil.h>
#include <folly/experimental/TestUtil.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/AsyncServerSocket.h>
#include <folly/io/async/EventBaseManager.h>
#include <folly/portability/GTest.h>
#include <folly/ssl/OpenSSLCertUtils.h>
#include <proxygen/httpclient/samples/curl/CurlClient.h>
#include <proxygen/httpserver/ResponseBuilder.h>
#include <proxygen/httpserver/ScopedHTTPServer.h>
#include <proxygen/lib/http/HTTPConnector.h>
#include <proxygen/lib/utils/TestUtils.h>
#include <wangle/client/ssl/SSLSession.h>

Go to the source code of this file.

Classes
class	ServerThread
class	Cb
class	DummyFilterFactory
class	DummyFilterFactory::DummyFilter
class	TestHandlerFactory
class	TestHandlerFactory::TestHandler
class	ScopedServerTest
class	ConnectionFilterTest

Functions
	TEST (MultiBind, HandlesListenFailures)
	TEST (HttpServerStartStop, TestRepeatStopCalls)
	TEST (SSL, SSLTest)
std::pair< std::unique_ptr< HTTPServer >, std::unique_ptr< ServerThread > >	setupServer (bool allowInsecureConnectionsOnSecureServer=false, folly::Optional< wangle::TLSTicketKeySeeds > seeds=folly::none)
	TEST (SSL, TestAllowInsecureOnSecureServer)
	TEST (SSL, DisallowInsecureOnSecureServer)
	TEST (SSL, TestResumptionWithTickets)
	TEST (SSL, TestResumptionAfterUpdateFails)
	TEST (SSL, TestUpdateTLSCredentials)
	TEST (GetListenSocket, TestNoBootstrap)
	TEST (GetListenSocket, TestBootstrapWithNoBinding)
	TEST (GetListenSocket, TestBootstrapWithBinding)
	TEST (UseExistingSocket, TestWithExistingAsyncServerSocket)
	TEST (UseExistingSocket, TestWithSocketFd)
	TEST (UseExistingSocket, TestWithMultipleSocketFds)
	TEST_F (ScopedServerTest, Start)
	TEST_F (ScopedServerTest, StartStrictSSL)
	TEST_F (ScopedServerTest, StartNotStrictSSL)
	TEST_F (ScopedServerTest, StartSSLWithInsecure)
	TEST_F (ConnectionFilterTest, Test)

Function Documentation

std::pair<std::unique_ptr<HTTPServer>, std::unique_ptr<ServerThread> > setupServer	(	bool	allowInsecureConnectionsOnSecureServer = false,
		folly::Optional< wangle::TLSTicketKeySeeds >	seeds = folly::none
	)

Definition at line 241 of file HTTPServerTest.cpp.

References proxygen::RequestHandlerChain::addThen(), EXPECT_TRUE, proxygen::HTTPServerOptions::handlerFactories, wangle::SSLContextConfig::isDefault, folly::gen::move, wangle::SSLContextConfig::setCertificate(), and proxygen::HTTPServerOptions::threads.

Referenced by TEST().

                                                                      {
  HTTPServer::IPConfig cfg{folly::SocketAddress("127.0.0.1", 0),
                           HTTPServer::Protocol::HTTP};
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
      kTestDir + "certs/test_cert1.pem", kTestDir + "certs/test_key1.pem", "");
  cfg.sslConfigs.push_back(sslCfg);
  cfg.allowInsecureConnectionsOnSecureServer =
      allowInsecureConnectionsOnSecureServer;
  cfg.ticketSeeds = seeds;

  HTTPServerOptions options;
  options.threads = 4;
  options.handlerFactories =
      RequestHandlerChain().addThen<TestHandlerFactory>().build();

  auto server = std::make_unique<HTTPServer>(std::move(options));

  std::vector<HTTPServer::IPConfig> ips{cfg};
  server->bind(ips);

  auto st = std::make_unique<ServerThread>(server.get());
  EXPECT_TRUE(st->start());
  return std::make_pair(std::move(server), std::move(st));
}

TEST	(	MultiBind	,
		HandlesListenFailures
	)

Definition at line 76 of file HTTPServerTest.cpp.

References addr, EXPECT_FALSE, folly::EventBaseManager::get(), folly::EventBaseManager::getEventBase(), folly::SocketAddress::getPort(), folly::gen::move, folly::netops::socket(), and proxygen::HTTPServerOptions::threads.

                                       {
  SocketAddress addr("127.0.0.1", 0);

  auto evb = EventBaseManager::get()->getEventBase();
  AsyncServerSocket::UniquePtr socket(new AsyncServerSocket(evb));
  socket->bind(addr);

  // Get the ephemeral port
  socket->getAddress(&addr);
  int port = addr.getPort();

  std::vector<HTTPServer::IPConfig> ips = {
    {
      folly::SocketAddress("127.0.0.1", port),
      HTTPServer::Protocol::HTTP
    }
  };

  HTTPServerOptions options;
  options.threads = 4;

  auto server = std::make_unique<HTTPServer>(std::move(options));

  // We have to bind both the sockets before listening on either
  server->bind(ips);

  // On kernel 2.6 trying to listen on a FD that another socket
  // has bound to fails. While in kernel 3.2 only when one socket tries
  // to listen on a FD that another socket is listening on fails.
  try {
    socket->listen(1024);
  } catch (const std::exception& ex) {
    return;
  }

  ServerThread st(server.get());
  EXPECT_FALSE(st.start());
}

TEST	(	HttpServerStartStop	,
		TestRepeatStopCalls
	)

Definition at line 115 of file HTTPServerTest.cpp.

References EXPECT_TRUE, and folly::gen::move.

                                               {
  HTTPServerOptions options;
  auto server = std::make_unique<HTTPServer>(std::move(options));
  auto st = std::make_unique<ServerThread>(server.get());
  EXPECT_TRUE(st->start());

  server->stop();
  // Calling stop again should be benign.
  server->stop();
}

TEST	(	SSL	,
		SSLTest
	)

Definition at line 154 of file HTTPServerTest.cpp.

References EXPECT_TRUE, wangle::SSLContextConfig::isDefault, folly::gen::move, wangle::SSLContextConfig::setCertificate(), and proxygen::HTTPServerOptions::threads.

                   {
  HTTPServer::IPConfig cfg{
    folly::SocketAddress("127.0.0.1", 0),
      HTTPServer::Protocol::HTTP};
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
    kTestDir + "certs/test_cert1.pem",
    kTestDir + "certs/test_key1.pem",
    "");
  cfg.sslConfigs.push_back(sslCfg);

  HTTPServerOptions options;
  options.threads = 4;

  auto server = std::make_unique<HTTPServer>(std::move(options));

  std::vector<HTTPServer::IPConfig> ips{cfg};
  server->bind(ips);

  ServerThread st(server.get());
  EXPECT_TRUE(st.start());

  folly::EventBase evb;
  auto ctx = std::make_shared<SSLContext>();
  folly::AsyncSSLSocket::UniquePtr sock(new folly::AsyncSSLSocket(ctx, &evb));
  Cb cb(sock.get());
  sock->connect(&cb, server->addresses().front().address, 1000);
  evb.loop();
  EXPECT_TRUE(cb.success);
}

TEST	(	SSL	,
		TestAllowInsecureOnSecureServer
	)

Definition at line 269 of file HTTPServerTest.cpp.

References proxygen::HTTPServer::addresses(), proxygen::HTTPConnector::connect(), folly::HHWheelTimer::DEFAULT_TICK_INTERVAL, EXPECT_EQ, CurlService::CurlClient::getResponse(), folly::EventBase::loop(), folly::TimeoutManager::NORMAL, CurlService::CurlClient::setFlowControlSettings(), CurlService::CurlClient::setLogging(), and setupServer().

                                           {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  std::tie(server, st) = setupServer(true);

  folly::EventBase evb;
  URL url(folly::to<std::string>(
      "http://localhost:", server->addresses().front().address.getPort()));
  HTTPHeaders headers;
  CurlClient curl(&evb, HTTPMethod::GET, url, nullptr, headers, "");
  curl.setFlowControlSettings(64 * 1024);
  curl.setLogging(false);
  HHWheelTimer::UniquePtr timer{new HHWheelTimer(
      &evb,
      std::chrono::milliseconds(HHWheelTimer::DEFAULT_TICK_INTERVAL),
      AsyncTimeout::InternalEnum::NORMAL,
      std::chrono::milliseconds(1000))};
  HTTPConnector connector(&curl, timer.get());
  connector.connect(&evb,
                    server->addresses().front().address,
                    std::chrono::milliseconds(1000));
  evb.loop();
  auto response = curl.getResponse();
  EXPECT_EQ(200, response->getStatusCode());
}

TEST	(	SSL	,
		DisallowInsecureOnSecureServer
	)

Definition at line 295 of file HTTPServerTest.cpp.

References proxygen::HTTPServer::addresses(), proxygen::HTTPConnector::connect(), folly::HHWheelTimer::DEFAULT_TICK_INTERVAL, EXPECT_EQ, CurlService::CurlClient::getResponse(), folly::EventBase::loop(), folly::TimeoutManager::NORMAL, CurlService::CurlClient::setFlowControlSettings(), CurlService::CurlClient::setLogging(), and setupServer().

                                          {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  std::tie(server, st) = setupServer(false);

  folly::EventBase evb;
  URL url(folly::to<std::string>(
      "http://localhost:", server->addresses().front().address.getPort()));
  HTTPHeaders headers;
  CurlClient curl(&evb, HTTPMethod::GET, url, nullptr, headers, "");
  curl.setFlowControlSettings(64 * 1024);
  curl.setLogging(false);
  HHWheelTimer::UniquePtr timer{new HHWheelTimer(
      &evb,
      std::chrono::milliseconds(HHWheelTimer::DEFAULT_TICK_INTERVAL),
      AsyncTimeout::InternalEnum::NORMAL,
      std::chrono::milliseconds(1000))};
  HTTPConnector connector(&curl, timer.get());
  connector.connect(&evb,
                    server->addresses().front().address,
                    std::chrono::milliseconds(1000));
  evb.loop();
  auto response = curl.getResponse();
  EXPECT_EQ(nullptr, response);
}

TEST	(	SSL	,
		TestResumptionWithTickets
	)

Definition at line 321 of file HTTPServerTest.cpp.

References proxygen::HTTPServer::addresses(), ASSERT_FALSE, ASSERT_NE, ASSERT_TRUE, wangle::TLSTicketKeySeeds::currentSeeds, folly::hexlify(), folly::EventBase::loop(), and setupServer().

                                     {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  wangle::TLSTicketKeySeeds seeds;
  seeds.currentSeeds.push_back(hexlify("hello"));
  std::tie(server, st) = setupServer(false, seeds);

  folly::EventBase evb;
  auto ctx = std::make_shared<SSLContext>();
  folly::AsyncSSLSocket::UniquePtr sock(new folly::AsyncSSLSocket(ctx, &evb));
  Cb cb(sock.get());
  sock->connect(&cb, server->addresses().front().address, 1000);
  evb.loop();
  ASSERT_TRUE(cb.success);
  ASSERT_NE(nullptr, cb.session.get());
  ASSERT_FALSE(cb.reusedSession);

  folly::AsyncSSLSocket::UniquePtr sock2(new folly::AsyncSSLSocket(ctx, &evb));
  sock2->setSSLSession(cb.session.get());
  Cb cb2(sock2.get());
  sock2->connect(&cb2, server->addresses().front().address, 1000);
  evb.loop();
  ASSERT_TRUE(cb2.success);
  ASSERT_NE(nullptr, cb2.session.get());
  ASSERT_TRUE(cb2.reusedSession);
}

TEST	(	SSL	,
		TestResumptionAfterUpdateFails
	)

Definition at line 348 of file HTTPServerTest.cpp.

References proxygen::HTTPServer::addresses(), ASSERT_FALSE, ASSERT_NE, ASSERT_TRUE, wangle::TLSTicketKeySeeds::currentSeeds, folly::hexlify(), folly::EventBase::loop(), setupServer(), and proxygen::HTTPServer::updateTicketSeeds().

                                          {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  wangle::TLSTicketKeySeeds seeds;
  seeds.currentSeeds.push_back(hexlify("hello"));
  std::tie(server, st) = setupServer(false, seeds);

  folly::EventBase evb;
  auto ctx = std::make_shared<SSLContext>();
  folly::AsyncSSLSocket::UniquePtr sock(new folly::AsyncSSLSocket(ctx, &evb));
  Cb cb(sock.get());
  sock->connect(&cb, server->addresses().front().address, 1000);
  evb.loop();
  ASSERT_TRUE(cb.success);
  ASSERT_NE(nullptr, cb.session.get());
  ASSERT_FALSE(cb.reusedSession);

  wangle::TLSTicketKeySeeds newSeeds;
  newSeeds.currentSeeds.push_back(hexlify("goodbyte"));
  server->updateTicketSeeds(newSeeds);

  folly::AsyncSSLSocket::UniquePtr sock2(new folly::AsyncSSLSocket(ctx, &evb));
  sock2->setSSLSession(cb.session.get());
  Cb cb2(sock2.get());
  sock2->connect(&cb2, server->addresses().front().address, 1000);
  evb.loop();
  ASSERT_TRUE(cb2.success);
  ASSERT_NE(nullptr, cb2.session.get());
  ASSERT_FALSE(cb2.reusedSession);

  folly::AsyncSSLSocket::UniquePtr sock3(new folly::AsyncSSLSocket(ctx, &evb));
  sock3->setSSLSession(cb2.session.get());
  Cb cb3(sock3.get());
  sock3->connect(&cb3, server->addresses().front().address, 1000);
  evb.loop();
  ASSERT_TRUE(cb3.success);
  ASSERT_NE(nullptr, cb3.session.get());
  ASSERT_TRUE(cb3.reusedSession);
}

TEST	(	SSL	,
		TestUpdateTLSCredentials
	)

Definition at line 388 of file HTTPServerTest.cpp.

References EXPECT_EQ, EXPECT_NE, EXPECT_TRUE, wangle::SSLContextConfig::isDefault, folly::gen::move, folly::test::TemporaryFile::path(), folly::readFile(), wangle::SSLContextConfig::setCertificate(), string, proxygen::HTTPServerOptions::threads, folly::writeFile(), and x.

                                    {
  // Set up a temporary file with credentials that we will update
  folly::test::TemporaryFile credFile;
  auto copyCreds = [path = credFile.path()](const std::string& certFile,
                                        const std::string& keyFile) {
    std::string certData, keyData;
    folly::readFile(certFile.c_str(), certData);
    folly::writeFile(certData, path.c_str(), O_WRONLY | O_CREAT | O_TRUNC);
    folly::writeFile(std::string("\n"), path.c_str(), O_WRONLY | O_APPEND);
    folly::readFile(keyFile.c_str(), keyData);
    folly::writeFile(keyData, path.c_str(), O_WRONLY | O_APPEND);
  };

  auto getCertDigest = [&](const X509* x) -> std::string {
    unsigned int n;
    unsigned char md[EVP_MAX_MD_SIZE];
    const EVP_MD* dig = EVP_sha256();

    if (!X509_digest(x, dig, md, &n)) {
      throw std::runtime_error("Cannot calculate digest");
    }
    return std::string((const char*)md, n);
  };

  HTTPServer::IPConfig cfg{folly::SocketAddress("127.0.0.1", 0),
                           HTTPServer::Protocol::HTTP};
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  copyCreds(kTestDir + "certs/test_cert1.pem",
            kTestDir + "certs/test_key1.pem");
  sslCfg.setCertificate(credFile.path().string(), credFile.path().string(), "");
  cfg.sslConfigs.push_back(sslCfg);

  HTTPServer::IPConfig insecureCfg{folly::SocketAddress("127.0.0.1", 0),
                                   HTTPServer::Protocol::HTTP};

  HTTPServerOptions options;
  options.threads = 4;

  auto server = std::make_unique<HTTPServer>(std::move(options));

  std::vector<HTTPServer::IPConfig> ips{cfg, insecureCfg};
  server->bind(ips);

  ServerThread st(server.get());
  EXPECT_TRUE(st.start());

  // First connection which should return old cert
  folly::EventBase evb;
  auto ctx = std::make_shared<SSLContext>();
  std::string certDigest1, certDigest2;

  // Connect and store digest of server cert
  auto connectAndFetchServerCert = [&]() -> std::string {
    folly::AsyncSSLSocket::UniquePtr sock(new folly::AsyncSSLSocket(ctx, &evb));
    Cb cb(sock.get());
    sock->connect(&cb, server->addresses().front().address, 1000);
    evb.loop();
    EXPECT_TRUE(cb.success);

    auto x509 = cb.getPeerCert();
    EXPECT_NE(x509, nullptr);
    return getCertDigest(x509);
  };

  // Original cert
  auto cert1 = connectAndFetchServerCert();
  EXPECT_EQ(cert1.length(), SHA256_DIGEST_LENGTH);

  // Update cert/key
  copyCreds(kTestDir + "certs/test_cert2.pem",
            kTestDir + "certs/test_key2.pem");
  server->updateTLSCredentials();
  evb.loop();

  // Should get new cert
  auto cert2 = connectAndFetchServerCert();
  EXPECT_EQ(cert2.length(), SHA256_DIGEST_LENGTH);
  EXPECT_NE(cert1, cert2);
}

TEST	(	GetListenSocket	,
		TestNoBootstrap
	)

Definition at line 469 of file HTTPServerTest.cpp.

References ASSERT_EQ, EXPECT_TRUE, and folly::gen::move.

                                       {
  HTTPServerOptions options;
  auto server = std::make_unique<HTTPServer>(std::move(options));
  auto st = std::make_unique<ServerThread>(server.get());
  EXPECT_TRUE(st->start());

  auto socketFd = server->getListenSocket();
  ASSERT_EQ(-1, socketFd);
}

TEST	(	GetListenSocket	,
		TestBootstrapWithNoBinding
	)

Definition at line 479 of file HTTPServerTest.cpp.

References ASSERT_EQ, wangle::TLSTicketKeySeeds::currentSeeds, proxygen::HTTPServer::getListenSocket(), folly::hexlify(), setupServer(), and proxygen::HTTPServer::stopListening().

                                                  {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  wangle::TLSTicketKeySeeds seeds;
  seeds.currentSeeds.push_back(hexlify("hello"));
  std::tie(server, st) = setupServer(false, seeds);

  // Stop listening on socket
  server->stopListening();

  auto socketFd = server->getListenSocket();
  ASSERT_EQ(-1, socketFd);
}

TEST	(	GetListenSocket	,
		TestBootstrapWithBinding
	)

Definition at line 493 of file HTTPServerTest.cpp.

References ASSERT_NE, wangle::TLSTicketKeySeeds::currentSeeds, proxygen::HTTPServer::getListenSocket(), folly::hexlify(), and setupServer().

                                                {
  std::unique_ptr<HTTPServer> server;
  std::unique_ptr<ServerThread> st;
  wangle::TLSTicketKeySeeds seeds;
  seeds.currentSeeds.push_back(hexlify("hello"));
  std::tie(server, st) = setupServer(false, seeds);

  auto socketFd = server->getListenSocket();
  ASSERT_NE(-1, socketFd);
}

TEST	(	UseExistingSocket	,
		TestWithExistingAsyncServerSocket
	)

Definition at line 504 of file HTTPServerTest.cpp.

References proxygen::RequestHandlerChain::addThen(), ASSERT_EQ, EXPECT_TRUE, proxygen::HTTPServerOptions::handlerFactories, folly::gen::move, and proxygen::HTTPServerOptions::useExistingSocket().

                                                           {
  AsyncServerSocket::UniquePtr serverSocket(new folly::AsyncServerSocket);
  serverSocket->bind(0);

  HTTPServer::IPConfig cfg{folly::SocketAddress("127.0.0.1", 0),
                           HTTPServer::Protocol::HTTP};
  std::vector<HTTPServer::IPConfig> ips{cfg};

  HTTPServerOptions options;
  options.handlerFactories =
      RequestHandlerChain().addThen<TestHandlerFactory>().build();
  // Use the existing AsyncServerSocket for binding
  auto existingFd = serverSocket->getSocket();
  options.useExistingSocket(std::move(serverSocket));

  auto server = std::make_unique<HTTPServer>(std::move(options));
  auto st = std::make_unique<ServerThread>(server.get());
  server->bind(ips);

  EXPECT_TRUE(st->start());

  auto socketFd = server->getListenSocket();
  ASSERT_EQ(existingFd, socketFd);
}

TEST	(	UseExistingSocket	,
		TestWithSocketFd
	)

Definition at line 529 of file HTTPServerTest.cpp.

References proxygen::RequestHandlerChain::addThen(), ASSERT_EQ, EXPECT_TRUE, proxygen::HTTPServerOptions::handlerFactories, folly::gen::move, and proxygen::HTTPServerOptions::useExistingSocket().

                                          {
  AsyncServerSocket::UniquePtr serverSocket(new folly::AsyncServerSocket);
  serverSocket->bind(0);

  HTTPServer::IPConfig cfg{folly::SocketAddress("127.0.0.1", 0),
                           HTTPServer::Protocol::HTTP};
  HTTPServerOptions options;
  options.handlerFactories =
      RequestHandlerChain().addThen<TestHandlerFactory>().build();
  // Use the socket fd from the existing AsyncServerSocket for binding
  auto existingFd = serverSocket->getSocket();
  options.useExistingSocket(existingFd);

  auto server = std::make_unique<HTTPServer>(std::move(options));
  auto st = std::make_unique<ServerThread>(server.get());
  std::vector<HTTPServer::IPConfig> ips{cfg};
  server->bind(ips);


  EXPECT_TRUE(st->start());

  auto socketFd = server->getListenSocket();
  ASSERT_EQ(existingFd, socketFd);
}

TEST	(	UseExistingSocket	,
		TestWithMultipleSocketFds
	)

Definition at line 554 of file HTTPServerTest.cpp.

References proxygen::RequestHandlerChain::addThen(), ASSERT_EQ, EXPECT_TRUE, proxygen::HTTPServerOptions::handlerFactories, folly::gen::move, and proxygen::HTTPServerOptions::useExistingSockets().

                                                   {
  AsyncServerSocket::UniquePtr serverSocket(new folly::AsyncServerSocket);
  serverSocket->bind(0);
  try {
    serverSocket->bind(1024);
  } catch (const std::exception& ex) {
    // This is fine because we are trying to bind to multiple ports
  }

  HTTPServer::IPConfig cfg{folly::SocketAddress("127.0.0.1", 0),
                           HTTPServer::Protocol::HTTP};
  HTTPServerOptions options;
  options.handlerFactories =
      RequestHandlerChain().addThen<TestHandlerFactory>().build();
  // Use the socket fd from the existing AsyncServerSocket for binding
  auto existingFds = serverSocket->getSockets();
  options.useExistingSockets(existingFds);

  auto server = std::make_unique<HTTPServer>(std::move(options));
  auto st = std::make_unique<ServerThread>(server.get());
  std::vector<HTTPServer::IPConfig> ips{cfg};
  server->bind(ips);


  EXPECT_TRUE(st->start());

  auto socketFd = server->getListenSocket();
  ASSERT_EQ(existingFds[0], socketFd);
}

TEST_F	(	ScopedServerTest	,
		Start
	)

Definition at line 658 of file HTTPServerTest.cpp.

References EXPECT_EQ.

                                {
  auto server = createScopedServer();
  auto client = connectPlainText();
  auto resp = client->getResponse();
  EXPECT_EQ(200, resp->getStatusCode());
}

TEST_F	(	ScopedServerTest	,
		StartStrictSSL
	)

Definition at line 665 of file HTTPServerTest.cpp.

References EXPECT_THROW, wangle::SSLContextConfig::isDefault, and wangle::SSLContextConfig::setCertificate().

                                         {
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
    "/path/should/not/exist",
    "/path/should/not/exist",
    "");
  cfg_.sslConfigs.push_back(sslCfg);
  EXPECT_THROW(createScopedServer(), std::exception);
}

TEST_F	(	ScopedServerTest	,
		StartNotStrictSSL
	)

Definition at line 676 of file HTTPServerTest.cpp.

References EXPECT_EQ, wangle::SSLContextConfig::isDefault, and wangle::SSLContextConfig::setCertificate().

                                            {
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
    "/path/should/not/exist",
    "/path/should/not/exist",
    "");
  cfg_.strictSSL = false;
  cfg_.sslConfigs.push_back(sslCfg);
  auto server = createScopedServer();
  auto client = connectPlainText();
  auto resp = client->getResponse();
  EXPECT_EQ(200, resp->getStatusCode());
}

TEST_F	(	ScopedServerTest	,
		StartSSLWithInsecure
	)

Definition at line 691 of file HTTPServerTest.cpp.

References EXPECT_EQ, wangle::SSLContextConfig::isDefault, and wangle::SSLContextConfig::setCertificate().

                                               {
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
    kTestDir + "certs/test_cert1.pem",
    kTestDir + "certs/test_key1.pem",
    "");
  cfg_.sslConfigs.push_back(sslCfg);
  cfg_.allowInsecureConnectionsOnSecureServer = true;
  auto server = createScopedServer();
  auto client = connectPlainText();
  auto resp = client->getResponse();
  EXPECT_EQ(200, resp->getStatusCode());

  client = connectSSL();
  resp = client->getResponse();
  EXPECT_EQ(200, resp->getStatusCode());
}

TEST_F	(	ConnectionFilterTest	,
		Test
	)

Definition at line 737 of file HTTPServerTest.cpp.

References wangle::SSLContextConfig::clientCAFile, wangle::SSLContextConfig::clientVerification, EXPECT_EQ, wangle::SSLContextConfig::isDefault, and wangle::SSLContextConfig::setCertificate().

                                   {
  wangle::SSLContextConfig sslCfg;
  sslCfg.isDefault = true;
  sslCfg.setCertificate(
      kTestDir + "certs/test_cert1.pem", kTestDir + "certs/test_key1.pem", "");
  sslCfg.clientCAFile = kTestDir + "certs/client_ca_cert.pem";
  // Permissive client auth.
  sslCfg.clientVerification = folly::SSLContext::SSLVerifyPeerEnum::VERIFY;
  cfg_.sslConfigs.push_back(sslCfg);

  auto server = createScopedServer();
  auto insecureClient = connectPlainText();
  auto certlessClient = connectSSL();
  auto certlessClient2 = connectSSL(kTestDir + "certs/ca_cert.pem");
  auto secureClient = connectSSL(kTestDir + "certs/ca_cert.pem",
                                 kTestDir + "certs/client_cert.pem",
                                 kTestDir + "certs/client_key.pem");

  // The following clients fail newConnectionFilter.
  EXPECT_EQ(nullptr, insecureClient->getResponse());
  EXPECT_EQ(nullptr, certlessClient->getResponse());
  EXPECT_EQ(nullptr, certlessClient2->getResponse());

  // Only secureClient passes.
  auto response = secureClient->getResponse();
  EXPECT_EQ(200, response->getStatusCode());

  // Check the header set by TestHandler.
  auto headers = response->getHeaders();
  EXPECT_EQ("testuser1", headers.getSingleOrEmpty("X-Client-CN"));
}