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;
  larra::xmpp::impl::MockSocket mockSocket{io.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";

  mockSocket.AddReceivedData(proxyResponse);

  bool connectSuccessful = false;

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

  io.run();

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

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

// Test 2: Connect via SOCKS proxy
TEST(Socks5ProxyTest, ConnectViaProxy) {
  constexpr std::uint16_t kSocksPort = 1080;
  constexpr std::uint16_t kAvailableUdpBufferSpaceForSocks = 262;

  boost::asio::io_context io;
  auto executor = io.get_executor();

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

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

  socket.AddReceivedData(expectedServerResponse);

  Socks5Proxy proxy{.hostname = "proxy.example.com", .port = kSocksPort};
  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();

        std::string expectedGreeting = "\x05\x01\x00";

        std::array<std::uint8_t, kAvailableUdpBufferSpaceForSocks> expectedRequest{};
        std::size_t reqLen = 0;

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

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

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

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

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

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

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

  io.run();
}