larra/tests/proxy.cpp

#include <gtest/gtest.h>

#include <larra/client/client.hpp>
#include <larra/impl/mock_socket.hpp>
#include <larra/proxy.hpp>

using namespace larra::xmpp;
using boost::asio::ip::tcp;
namespace asio = boost::asio;

class ProxyTest : public ::testing::Test {
 protected:
  boost::asio::io_context io_context;
  larra::xmpp::impl::MockSocket mock_socket{io_context.get_executor()};
};

// Test 1: Connect via HTTP proxy with successful server response
TEST_F(ProxyTest, ConnectViaHttpProxy_SuccessfulResponse) {
  HttpProxy proxy{"proxy_host", 8080};

  std::string targetHost = "target_host";
  uint16_t targetPort = 80;

  std::string expectedRequest =
      std::format("CONNECT {}:{} HTTP/1.1\r\nHost: {}:{}\r\n\r\n", targetHost, targetPort, targetHost, targetPort);

  std::string proxyResponse = "HTTP/1.1 200 Connection established\r\n\r\n";

  mock_socket.AddReceivedData(proxyResponse);

  bool connectSuccessful = false;

  asio::co_spawn(
      io_context,
      [&]() -> asio::awaitable<void> {
        try {
          co_await client::impl::ConnectViaProxy(mock_socket, proxy, targetHost, targetPort);
          connectSuccessful = true;
        } catch(...) {
          connectSuccessful = false;
        }
      },
      asio::detached);

  io_context.run();

  std::string sentData = mock_socket.GetSentData();

  EXPECT_EQ(sentData, expectedRequest);
  EXPECT_TRUE(connectSuccessful);
}

// Test 2: Connect via SOCKS proxy
TEST(Socks5ProxyTest, ConnectViaProxy) {
  boost::asio::io_context io;
  auto executor = io.get_executor();

  larra::xmpp::impl::MockSocket socket{executor};

  // expected server responses
  std::string serverResponse;
  serverResponse += "\x05\x00";          // VER, METHOD
  serverResponse += "\x05\x00\x00\x01";  // VER, REP, RSV, ATYP (IPv4)
  serverResponse += "\x7F\x00\x00\x01";  // BND.ADDR (127.0.0.1)
  serverResponse += "\x1F\x90";          // BND.PORT (8080)

  socket.AddReceivedData(serverResponse);

  Socks5Proxy proxy{"proxy.example.com", 1080};
  std::string targetHostname = "target.example.com";
  std::uint16_t targetPort = 80;

  boost::asio::co_spawn(
      executor,
      [&]() -> boost::asio::awaitable<void> {
        co_await client::impl::ConnectViaProxy(socket, proxy, targetHostname, targetPort);

        auto sentData = socket.GetSentData();

        // Expected client greeting
        std::string expectedGreeting = "\x05\x01\x00";

        // Expected CONNECT request
        std::array<std::uint8_t, 262> expectedRequest{};
        std::size_t req_len = 0;

        expectedRequest[req_len++] = 0x05;  // VER
        expectedRequest[req_len++] = 0x01;  // CMD: CONNECT
        expectedRequest[req_len++] = 0x00;  // RSV
        expectedRequest[req_len++] = 0x03;  // ATYP: DOMAINNAME

        expectedRequest[req_len++] = static_cast<std::uint8_t>(targetHostname.size());  // domain length

        std::memcpy(&expectedRequest[req_len], targetHostname.data(), targetHostname.size());
        req_len += targetHostname.size();

        std::uint16_t networkOrderPort = htons(targetPort);
        expectedRequest[req_len++] = static_cast<std::uint8_t>((networkOrderPort >> 8) & 0xFF);
        expectedRequest[req_len++] = static_cast<std::uint8_t>(networkOrderPort & 0xFF);

        std::string expectedData = expectedGreeting;
        auto transformed_view = expectedRequest | std::views::take(req_len) | std::views::transform([](std::uint8_t byte) {
                                  return static_cast<char>(byte);
                                });

        expectedData.append(std::ranges::to<std::string>(transformed_view));
        EXPECT_EQ(sentData, expectedData);

        co_return;
      },
      boost::asio::detached);

  io.run();
}

/*
// Test 3: Connect via system configured proxy
TEST_F(ProxyTest, ConnectViaSystemProxy_HttpProxy) {
    // Set the environment variable for the system proxy
    const char* original_http_proxy = std::getenv("http_proxy");
    setenv("http_proxy", "http://proxy_host:8080", 1);

    std::string target_host = "target_host";
    uint16_t target_port = 80;

    std::string expected_request = std::format(
        "CONNECT {}:{} HTTP/1.1\r\nHost: {}:{}\r\n\r\n",
        target_host, target_port, target_host, target_port);

    std::string proxy_response = "HTTP/1.1 200 Connection established\r\n\r\n";

    mock_socket.AddReceivedData(proxy_response);

    bool connect_successful = false;

    asio::co_spawn(io_context, [&]() -> asio::awaitable<void> {
        try {
            SystemConfiguredProxy proxy;
            co_await client::impl::ConnectToServer(mock_socket, proxy, target_host, target_port);
            connect_successful = true;
        } catch (...) {
            connect_successful = false;
        }
    }, asio::detached);

    io_context.run();

    std::string sent_data = mock_socket.GetSentData();

    EXPECT_EQ(sent_data, expected_request);
    EXPECT_TRUE(connect_successful);

    // Restore the original environment variable
    if (original_http_proxy) {
        setenv("http_proxy", original_http_proxy, 1);
    } else {
        unsetenv("http_proxy");
    }
}

// Test 4: Incorrect proxy data
TEST_F(ProxyTest, ConnectViaHttpProxy_IncorrectData) {
    HttpProxy proxy{"proxy_host", 8080};

    std::string target_host = "target_host";
    uint16_t target_port = 80;

    std::string expected_request = std::format(
        "CONNECT {}:{} HTTP/1.1\r\nHost: {}:{}\r\n\r\n",
        target_host, target_port, target_host, target_port);

    // Simulate an incorrect response from the proxy server
    std::string proxy_response = "HTTP/1.1 400 Bad Request\r\n\r\n";

    mock_socket.AddReceivedData(proxy_response);

    bool connect_successful = false;
    std::string error_message;

    asio::co_spawn(io_context, [&]() -> asio::awaitable<void> {
        try {
            co_await client::impl::ConnectToServer(mock_socket, proxy, target_host, target_port);
            connect_successful = true;
        } catch (const std::runtime_error& e) {
            connect_successful = false;
            error_message = e.what();
        }
    }, asio::detached);

    io_context.run();

    std::string sent_data = mock_socket.GetSentData();

    EXPECT_EQ(sent_data, expected_request);
    EXPECT_FALSE(connect_successful);
    EXPECT_FALSE(error_message.empty());
}
*/