// Copyright 2012 The Goma Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.


#include "http_rpc.h"

#include <string>
#include <sstream>

#include "absl/memory/memory.h"
#include "callback.h"
#include "compiler_proxy_info.h"
#include "compiler_specific.h"
#include "fake_tls_engine.h"
MSVC_PUSH_DISABLE_WARNING_FOR_PROTO()
#include "google/protobuf/message_lite.h"
#include "google/protobuf/io/gzip_stream.h"
#include "google/protobuf/io/zero_copy_stream.h"
#include "google/protobuf/io/zero_copy_stream_impl.h"
#include "google/protobuf/io/zero_copy_stream_impl_lite.h"
MSVC_POP_WARNING()
#include "ioutil.h"
#include "lockhelper.h"
#include "mock_socket_factory.h"
#include "platform_thread.h"
MSVC_PUSH_DISABLE_WARNING_FOR_PROTO()
#include "prototmp/goma_data.pb.h"
MSVC_POP_WARNING()
#include "scoped_fd.h"
#include "socket_factory.h"
#include "worker_thread_manager.h"

#include <glog/logging.h>
#include <gtest/gtest.h>

using std::string;

namespace devtools_goma {

class HttpRPCTest : public ::testing::Test {
 protected:
  class TestLookupFileContext {
   public:
    enum State { INIT, CALL, DONE };
    TestLookupFileContext(HttpRPC* http_rpc,
                          OneshotClosure* callback)
        : http_rpc_(http_rpc),
          callback_(callback),
          r_(0),
          state_(INIT) {
    }

    HttpRPC* http_rpc_;
    OneshotClosure* callback_;
    LookupFileReq req_;
    LookupFileResp resp_;
    HttpRPC::Status status_;
    int r_;
    int state_;
  };

  HttpRPCTest() : pool_(-1) {}

  void SetUp() override {
    wm_ = absl::make_unique<WorkerThreadManager>();
    wm_->Start(1);
    pool_ = wm_->StartPool(1, "test");
    mock_server_ = absl::make_unique<MockSocketServer>(wm_.get());
  }
  void TearDown() override {
    mock_server_.reset();
    wm_->Finish();
    wm_.reset();
    pool_ = -1;
  }

  void RunTestLookupFile(TestLookupFileContext* tc) {
    wm_->RunClosureInPool(
        FROM_HERE,
        pool_,
        NewCallback(
            this, &HttpRPCTest::DoTestLookupFile, tc),
        WorkerThreadManager::PRIORITY_LOW);
  }

  void DoTestLookupFile(TestLookupFileContext* tc) {
    if (tc->callback_ != nullptr) {
      tc->http_rpc_->CallWithCallback(
          "/l", &tc->req_, &tc->resp_, &tc->status_, tc->callback_);
      AutoLock lock(&mu_);
      tc->state_ = TestLookupFileContext::CALL;
      cond_.Signal();
    } else {
      int r = tc->http_rpc_->Call(
          "/l", &tc->req_, &tc->resp_, &tc->status_);
      AutoLock lock(&mu_);
      tc->r_ = r;
      tc->state_ = TestLookupFileContext::DONE;
      cond_.Signal();
    }
  }

  void WaitTestLookupFile(TestLookupFileContext* tc) {
    wm_->RunClosureInPool(
        FROM_HERE,
        pool_,
        NewCallback(
            this, &HttpRPCTest::DoWaitTestLookupFile, tc),
        WorkerThreadManager::PRIORITY_LOW);
  }

  void DoWaitTestLookupFile(TestLookupFileContext* tc) {
    tc->http_rpc_->Wait(&tc->status_);
    AutoLock lock(&mu_);
    tc->state_ = TestLookupFileContext::DONE;
    cond_.Signal();
  }

  OneshotClosure* NewDoneCallback(bool* done) {
    {
      AutoLock lock(&mu_);
      *done = false;
    }
    return NewCallback(
        this, &HttpRPCTest::DoneCallback, done);
  }

  void DoneCallback(bool* done) {
    AutoLock lock(&mu_);
    *done = true;
    cond_.Signal();
  }

  void SerializeCompressToString(
      const google::protobuf::Message& msg,
      int compression_level,
      string* serialized) {
    string buf;
    google::protobuf::io::StringOutputStream stream(&buf);
    google::protobuf::io::GzipOutputStream::Options options;
    options.format = google::protobuf::io::GzipOutputStream::ZLIB;
    options.compression_level = compression_level;
    google::protobuf::io::GzipOutputStream gzip_stream(&stream, options);
    msg.SerializeToZeroCopyStream(&gzip_stream);
    ASSERT_TRUE(gzip_stream.Close());
    ASSERT_GE(buf.size(), 1);
    ASSERT_FALSE(buf[1] >> 5 & 1)
        << "serialized has FDICT, which should not be supported";
    absl::string_view v(buf);
    v.remove_prefix(2);
    *serialized = string(v);
  }

  std::unique_ptr<WorkerThreadManager> wm_;
  int pool_;
  std::unique_ptr<MockSocketServer> mock_server_;
  mutable Lock mu_;
  ConditionVariable cond_;
};

TEST_F(HttpRPCTest, PingFail) {
  std::unique_ptr<MockSocketFactory> socket_factory(
      new MockSocketFactory(-1));
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 80;
  HttpClient http_client(
      std::move(socket_factory), nullptr, options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(0, r);
  EXPECT_EQ("error: failed to connect to backend servers",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
}

TEST_F(HttpRPCTest, PingRejected) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 401 Unauthorized\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 5\r\n\r\n"
          << "error";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      new MockSocketFactory(socks[1], &socket_status));
  socket_factory->set_dest("clients5.google.com:80");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(80);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 80;
  HttpClient http_client(
      std::move(socket_factory), nullptr, options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(401, r);
  EXPECT_EQ("running: access to backend servers was rejected.",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, PingOk) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 2\r\n\r\n"
          << "ok";
  mock_server_->ServerWrite(socks[0], resp_ss.str());

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      new MockSocketFactory(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:80");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(80);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 80;
  HttpClient http_client(
      std::move(socket_factory), nullptr, options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(200, r);
  EXPECT_EQ("ok", http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, CallLookupFile) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  LookupFileReq req;
  string serialized_req;
  req.SerializeToString(&serialized_req);
  std::ostringstream req_ss;
  req_ss << "POST /l HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: " << serialized_req.size() << "\r\n\r\n"
         << serialized_req;

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  LookupFileResp resp;
  string serialized_resp;
  resp.SerializeToString(&serialized_resp);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/x-protocol-buffer\r\n"
          << "Content-Length: " << serialized_resp.size() << "\r\n\r\n"
          << serialized_resp;
  mock_server_->ServerWrite(socks[0], resp_ss.str());

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      new MockSocketFactory(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:80");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(80);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 80;
  HttpClient http_client(
      std::move(socket_factory), nullptr, options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  rpc_options.start_compression = false;
  HttpRPC http_rpc(&http_client, rpc_options);
  TestLookupFileContext tc(&http_rpc, nullptr);
  RunTestLookupFile(&tc);
  {
    AutoLock lock(&mu_);
    while (tc.state_ != TestLookupFileContext::DONE) {
      cond_.Wait(&mu_);
    }

    EXPECT_EQ(req_expected, req_buf);
    EXPECT_EQ(0, tc.r_);
    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_TRUE(tc.status_.finished);
    EXPECT_EQ(0, tc.status_.err);
    EXPECT_EQ("", tc.status_.err_message);
    EXPECT_EQ(200, tc.status_.http_return_code);
  }
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, CallAsyncLookupFile) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  LookupFileReq req;
  string serialized_req;
  req.SerializeToString(&serialized_req);
  std::ostringstream req_ss;
  req_ss << "POST /l HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: " << serialized_req.size() << "\r\n\r\n"
         << serialized_req;

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  LookupFileResp resp;
  string serialized_resp;
  resp.SerializeToString(&serialized_resp);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/x-protocol-buffer\r\n"
          << "Content-Length: " << serialized_resp.size() << "\r\n\r\n"
          << serialized_resp;

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      new MockSocketFactory(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:80");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(80);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 80;
  HttpClient http_client(
      std::move(socket_factory), nullptr, options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  rpc_options.start_compression = false;
  HttpRPC http_rpc(&http_client, rpc_options);
  bool done = false;
  TestLookupFileContext tc(&http_rpc, NewDoneCallback(&done));
  RunTestLookupFile(&tc);
  {
    AutoLock lock(&mu_);
    while (tc.state_ != TestLookupFileContext::CALL) {
      cond_.Wait(&mu_);
    }

    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_FALSE(tc.status_.finished);
  }

  mock_server_->ServerWrite(socks[0], resp_ss.str());
  WaitTestLookupFile(&tc);

  {
    AutoLock lock(&mu_);
    while (!done) {
      cond_.Wait(&mu_);
    }
    while (tc.state_ != TestLookupFileContext::DONE) {
      cond_.Wait(&mu_);
    }
    EXPECT_EQ(req_expected, req_buf);
    EXPECT_EQ(0, tc.r_);
    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_TRUE(tc.status_.finished);
    EXPECT_EQ(0, tc.status_.err);
    EXPECT_EQ("", tc.status_.err_message);
    EXPECT_EQ(200, tc.status_.http_return_code);
  }
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEnginePingFail) {
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(-1));
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(
      std::move(socket_factory),
      std::move(tls_engine_factory),
      options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(0, r);
  EXPECT_EQ("error: failed to connect to backend servers",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
}

TEST_F(HttpRPCTest, TLSEnginePingRejected) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 401 Unauthorized\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 5\r\n\r\n"
          << "error";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(401, r);
  EXPECT_EQ("running: access to backend servers was rejected.",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEnginePingOk) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 2\r\n\r\n"
          << "ok";
  mock_server_->ServerWrite(socks[0], resp_ss.str());

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(200, r);
  EXPECT_EQ("ok", http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineCallLookupFile) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  LookupFileReq req;
  string serialized_req;
  req.SerializeToString(&serialized_req);
  std::ostringstream req_ss;
  req_ss << "POST /l HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: " << serialized_req.size() << "\r\n\r\n"
         << serialized_req;

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  LookupFileResp resp;
  string serialized_resp;
  resp.SerializeToString(&serialized_resp);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/x-protocol-buffer\r\n"
          << "Content-Length: " << serialized_resp.size() << "\r\n\r\n"
          << serialized_resp;
  mock_server_->ServerWrite(socks[0], resp_ss.str());

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  rpc_options.start_compression = false;
  HttpRPC http_rpc(&http_client, rpc_options);
  TestLookupFileContext tc(&http_rpc, nullptr);
  RunTestLookupFile(&tc);
  {
    AutoLock lock(&mu_);
    while (tc.state_ != TestLookupFileContext::DONE) {
      cond_.Wait(&mu_);
    }

    EXPECT_EQ(req_expected, req_buf);
    EXPECT_EQ(0, tc.r_);
    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_TRUE(tc.status_.finished);
    EXPECT_EQ(0, tc.status_.err);
    EXPECT_EQ("", tc.status_.err_message);
    EXPECT_EQ(200, tc.status_.http_return_code);
  }
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineCallLookupFileDeflate) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  const int kCompressionLevel = 3;
  LookupFileReq req;
  string serialized_req;
  SerializeCompressToString(req, kCompressionLevel, &serialized_req);
  std::ostringstream req_ss;
  req_ss << "POST /l HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: " << serialized_req.size() << "\r\n"
         << "Accept-Encoding: deflate\r\n"
         << "Content-Encoding: deflate\r\n\r\n"
         << serialized_req;

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  LookupFileResp resp;
  string serialized_resp;
  SerializeCompressToString(resp, kCompressionLevel, &serialized_resp);
  LOG(INFO) << "resp length=" << serialized_resp.size()
            << " data=" << serialized_resp;
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/x-protocol-buffer\r\n"
          << "Accept-Encoding: deflate\r\n"
          << "Content-Encoding: deflate\r\n"
          << "Content-Length: " << serialized_resp.size() << "\r\n\r\n"
          << serialized_resp;
  mock_server_->ServerWrite(socks[0], resp_ss.str());

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  rpc_options.start_compression = true;
  rpc_options.compression_level = kCompressionLevel;
  rpc_options.accept_encoding = "deflate";
  HttpRPC http_rpc(&http_client, rpc_options);
  TestLookupFileContext tc(&http_rpc, nullptr);
  RunTestLookupFile(&tc);
  {
    AutoLock lock(&mu_);
    while (tc.state_ != TestLookupFileContext::DONE) {
      cond_.Wait(&mu_);
    }

    EXPECT_EQ(req_expected, req_buf);
    EXPECT_EQ(0, tc.r_);
    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_TRUE(tc.status_.finished);
    EXPECT_EQ(0, tc.status_.err);
    EXPECT_EQ("", tc.status_.err_message);
    EXPECT_EQ(200, tc.status_.http_return_code);
  }
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineCallAsyncLookupFile) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  LookupFileReq req;
  string serialized_req;
  req.SerializeToString(&serialized_req);
  std::ostringstream req_ss;
  req_ss << "POST /l HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: " << serialized_req.size() << "\r\n\r\n"
         << serialized_req;

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  LookupFileResp resp;
  string serialized_resp;
  resp.SerializeToString(&serialized_resp);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/x-protocol-buffer\r\n"
          << "Content-Length: " << serialized_resp.size() << "\r\n\r\n"
          << serialized_resp;

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  rpc_options.start_compression = false;
  HttpRPC http_rpc(&http_client, rpc_options);
  bool done = false;
  TestLookupFileContext tc(&http_rpc, NewDoneCallback(&done));
  RunTestLookupFile(&tc);
  {
    AutoLock lock(&mu_);
    while (tc.state_ != TestLookupFileContext::CALL) {
      cond_.Wait(&mu_);
    }

    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_FALSE(tc.status_.finished);
  }

  mock_server_->ServerWrite(socks[0], resp_ss.str());
  WaitTestLookupFile(&tc);

  {
    AutoLock lock(&mu_);
    while (!done) {
      cond_.Wait(&mu_);
    }
    while (tc.state_ != TestLookupFileContext::DONE) {
      cond_.Wait(&mu_);
    }
    EXPECT_EQ(req_expected, req_buf);
    EXPECT_EQ(0, tc.r_);
    EXPECT_TRUE(tc.status_.connect_success);
    EXPECT_TRUE(tc.status_.finished);
    EXPECT_EQ(0, tc.status_.err);
    EXPECT_EQ("", tc.status_.err_message);
    EXPECT_EQ(200, tc.status_.http_return_code);
  }
  http_client.WaitNoActive();
  EXPECT_TRUE(socket_status.is_owned());
  EXPECT_FALSE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineFailWithTLSErrorAtSetData) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 2\r\n\r\n"
          << "ok";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetBroken(FakeTLSEngine::FAKE_TLS_SET_BROKEN);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(500, r);
  EXPECT_EQ("running: failed to send request to backend servers",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineFailWithTLSErrorAtRead) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetBroken(FakeTLSEngine::FAKE_TLS_READ_BROKEN);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(500, r);
  EXPECT_EQ("running: failed to send request to backend servers",
            http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineFailWithTLSErrorAtWrite) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  string req_buf;
  mock_server_->ServerRead(socks[0], &req_buf);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetBroken(FakeTLSEngine::FAKE_TLS_WRITE_BROKEN);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(500, r);
  EXPECT_EQ("running: failed to send request to backend servers",
            http_client.GetHealthStatusMessage());
  // Nothing should be requested to the server.
  EXPECT_EQ("", req_buf);
  mock_server_->ServerClose(socks[0]);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerTimeoutSendingHeaderShouldBeError) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  mock_server_->ServerWait(absl::Milliseconds(1500));
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  status.timeout_secs.emplace_back(1);
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(ERR_TIMEOUT, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseWithoutContentLengthShouldBeOk) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n\r\n"
          << "ok";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(200, r);
  EXPECT_EQ("ok", http_client.GetHealthStatusMessage());
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_FALSE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseBeforeSendingHeaderShouldBeError) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(FAIL, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseBeforeReadingAnythingShouldBeError) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
    HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  int r = http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(500, r);
  EXPECT_EQ(FAIL, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseBeforeSendingEnoughDataShouldBeError) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n"
          << "Content-Length: 128\r\n\r\n"
          << "ok";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(FAIL, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseWithoutContentLengthShouldNotHangUp) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Content-Type: text/plain\r\n\r\n"
          << "dummydata";
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetMaxReadSize(10);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(OK, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_FALSE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

TEST_F(HttpRPCTest, TLSEngineServerCloseWithoutEndOfChunkShouldNotHangUp) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Transfer-Encoding: chunked\r\n"
          << "Content-Type: text/plain\r\n\r\n"
          << "1\r\na";  // not sending all data but closed.
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetMaxReadSize(10);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(FAIL, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}


TEST_F(HttpRPCTest, TLSEngineServerCloseWithoutAllChunksShouldNotHangUp) {
  int socks[2];
  ASSERT_EQ(0, OpenSocketPairForTest(socks));
  std::ostringstream req_ss;
  req_ss << "POST /pingz HTTP/1.1\r\n"
         << "Host: clients5.google.com\r\n"
         << "User-Agent: " << kUserAgentString << "\r\n"
         << "Content-Type: binary/x-protocol-buffer\r\n"
         << "Content-Length: 0\r\n\r\n";

  const string req_expected = req_ss.str();
  string req_buf;
  req_buf.resize(req_expected.size());
  mock_server_->ServerRead(socks[0], &req_buf);
  std::ostringstream resp_ss;
  resp_ss << "HTTP/1.1 200 OK\r\n"
          << "Transfer-Encoding: chunked\r\n"
          << "Content-Type: text/plain\r\n\r\n"
          << "1\r\na123\r\nbcd";  // not sending all data but closed.
  mock_server_->ServerWrite(socks[0], resp_ss.str());
  mock_server_->ServerClose(socks[0]);

  MockSocketFactory::SocketStatus socket_status;
  std::unique_ptr<MockSocketFactory> socket_factory(
      absl::make_unique<MockSocketFactory>(socks[1], &socket_status));

  socket_factory->set_dest("clients5.google.com:443");
  socket_factory->set_host_name("clients5.google.com");
  socket_factory->set_port(443);
  std::unique_ptr<FakeTLSEngineFactory> tls_engine_factory(
      absl::make_unique<FakeTLSEngineFactory>());
  tls_engine_factory->SetMaxReadSize(10);
  HttpClient::Options options;
  options.dest_host_name = "clients5.google.com";
  options.dest_port = 443;
  options.use_ssl = true;
  HttpClient http_client(std::move(socket_factory),
                         std::move(tls_engine_factory),
                         options, wm_.get());
  HttpRPC::Options rpc_options;
  rpc_options.content_type_for_protobuf = "binary/x-protocol-buffer";
  HttpRPC http_rpc(&http_client, rpc_options);
  HttpRPC::Status status;
  http_rpc.Ping(wm_.get(), "/pingz", &status);
  EXPECT_EQ(req_expected, req_buf);
  EXPECT_EQ(FAIL, status.err);
  http_client.WaitNoActive();
  EXPECT_FALSE(socket_status.is_owned());
  EXPECT_TRUE(socket_status.is_closed());
  EXPECT_TRUE(socket_status.is_err());
  EXPECT_FALSE(socket_status.is_released());
}

}  // namespace devtools_goma