Add UpstreamConnectionPool test suite to build

    test_http_proxy_paths.cpp

    ../src/http/HttpProxyPath.cpp)

add_test(NAME test_http_proxy_paths COMMAND test_http_proxy_paths)

add_executable(test_upstreamconnectionpool test_upstreamconnectionpool.cpp)

target_link_libraries(test_upstreamconnectionpool PRIVATE proxyplus_core)

add_test(NAME test_upstreamconnectionpool COMMAND test_upstreamconnectionpool)

#include <atomic>

#include <cassert>

#include <chrono>

#include <iostream>

#include <mutex>

#include <thread>

#include <vector>

#include <netplus/socket.h>

#include "../src/http/UpstreamConnectionPool.h"

using proxyplus::http::UpstreamConnectionPool;

namespace {

// Minimal listener: accepts connections in the background and just holds them open (never

// speaks HTTP back) -- HttpClient's constructor only needs the TCP connect() to succeed for a

// plain "http://" origin (see resetConnection()'s plain-TCP branch), it never has to get a real

// response for these tests, which only exercise acquire()/release() themselves, not a request.

class AcceptingServer {

public:

    explicit AcceptingServer(int port) : _portNum(port), _sock("127.0.0.1", port, 64, -1) {

        _sock.bind();

        _sock.listen();

        _thread = std::thread([this] { run(); });

    }

    ~AcceptingServer() {

        _stop.store(true);

        // Nudge accept() out of its blocking wait so the thread can see _stop and exit.

        netplus::tcp nudge;

        try {

            nudge.connect("127.0.0.1", _portNum);

        } catch (...) {}

        _thread.join();

    }

    int acceptCount() const { return _accepted.load(); }

private:

    void run() {

        while (!_stop.load()) {

            // tcp::accept() expects the caller to have already constructed the concrete child

            // socket object and just overwrites its fd (see netplus/src/posix/tcp.cpp) --

            // matches the exact pattern used by libnetplus's own event-loop accept path

            // (kqueue.cpp/epoll.cpp's ConnectEventHandler: `csock = std::make_unique<tcp>(-1)`

            // before calling accept()).

            std::unique_ptr<netplus::socket> csock = std::make_unique<netplus::tcp>(-1);

            try {

                _sock.accept(csock, false);

            } catch (...) {

                continue;

            }

            if (_stop.load() || !csock) continue;

            _accepted.fetch_add(1);

            std::lock_guard<std::mutex> lk(_heldMutex);

            _held.push_back(std::move(csock));

        }

    }

    int _portNum;

    netplus::tcp _sock;

    std::thread _thread;

    std::atomic<bool> _stop{false};

    std::atomic<int> _accepted{0};

    std::mutex _heldMutex;

    std::vector<std::unique_ptr<netplus::socket>> _held;

};

libhttppp::HttpUrl urlFor(int port) {

    return libhttppp::HttpUrl("http://127.0.0.1:" + std::to_string(port) + "/");

}

} // namespace

int main() {

    // --- acquire()/release() reuses the same connection for a second acquire ---

    {

        AcceptingServer server(19801);

        UpstreamConnectionPool pool(/*maxIdlePerOrigin=*/8, /*idleTimeoutSeconds=*/60);

        libhttppp::HttpUrl url = urlFor(19801);

        auto c1 = pool.acquire(url, /*vers=*/0, /*timeoutSec=*/5, netplus::TlsTrustPolicy{});

        assert(server.acceptCount() == 1);

        pool.release(std::move(c1), url);

        auto c2 = pool.acquire(url, /*vers=*/0, /*timeoutSec=*/5, netplus::TlsTrustPolicy{});

        assert(server.acceptCount() == 1); // reused -- no second accept()

        pool.release(std::move(c2), url);

        std::cout << "PASS: acquire/release reuses the same connection" << std::endl;

    }

    // --- releasing more than maxIdlePerOrigin discards the excess (they don't accumulate) ---

    {

        AcceptingServer server(19802);

        const int cap = 2;

        UpstreamConnectionPool pool(cap, /*idleTimeoutSeconds=*/60);

        libhttppp::HttpUrl url = urlFor(19802);

        std::vector<std::unique_ptr<libhttppp::HttpClient>> clients;

        for (int i = 0; i < cap + 2; ++i) {

            clients.push_back(pool.acquire(url, 0, 5, netplus::TlsTrustPolicy{}));

        }

        assert(server.acceptCount() == cap + 2); // all distinct, none reused yet

        for (auto &c : clients) pool.release(std::move(c), url);

        clients.clear();

        // Only `cap` should have been kept idle -- acquiring `cap` more must all be reuses,

        // then one further acquire must open a genuinely new connection.

        int acceptBefore = server.acceptCount();

        for (int i = 0; i < cap; ++i) {

            auto c = pool.acquire(url, 0, 5, netplus::TlsTrustPolicy{});

            pool.release(std::move(c), url);

        }

        assert(server.acceptCount() == acceptBefore); // all `cap` reused, no new accepts

        std::cout << "PASS: releases beyond maxIdlePerOrigin are discarded, not accumulated"

                  << std::endl;

    }

    // --- an idle entry older than idleTimeoutSeconds is discarded, not handed back stale ---

    {

        AcceptingServer server(19803);

        UpstreamConnectionPool pool(/*maxIdlePerOrigin=*/8, /*idleTimeoutSeconds=*/1);

        libhttppp::HttpUrl url = urlFor(19803);

        auto c1 = pool.acquire(url, 0, 5, netplus::TlsTrustPolicy{});

        assert(server.acceptCount() == 1);

        pool.release(std::move(c1), url);

        std::this_thread::sleep_for(std::chrono::milliseconds(1200));

        auto c2 = pool.acquire(url, 0, 5, netplus::TlsTrustPolicy{});

        assert(server.acceptCount() == 2); // stale entry discarded, fresh connect instead

        pool.release(std::move(c2), url);

        std::cout << "PASS: idle entries older than idleTimeoutSeconds are discarded"

                  << std::endl;

    }

    // --- concurrent acquire/release from several threads doesn't crash or corrupt the pool ---

    {

        AcceptingServer server(19804);

        UpstreamConnectionPool pool(/*maxIdlePerOrigin=*/4, /*idleTimeoutSeconds=*/60);

        libhttppp::HttpUrl url = urlFor(19804);

        constexpr int kThreads = 8;

        constexpr int kIterations = 50;

        std::vector<std::thread> workers;

        for (int t = 0; t < kThreads; ++t) {

            workers.emplace_back([&pool, &url] {

                for (int i = 0; i < kIterations; ++i) {

                    auto c = pool.acquire(url, 0, 5, netplus::TlsTrustPolicy{});

                    pool.release(std::move(c), url);

                }

            });

        }

        for (auto &w : workers) w.join();

        // No crash/hang above is the actual assertion; the accept count is bounded by however

        // many concurrent connections were genuinely in flight at once (<= kThreads), nowhere

        // near kThreads * kIterations -- confirms reuse is happening under real concurrency too.

        assert(server.acceptCount() <= kThreads);

        std::cout << "PASS: concurrent acquire/release across " << kThreads

                  << " threads is safe (accepted " << server.acceptCount()

                  << " distinct connections for " << (kThreads * kIterations) << " acquires)"

                  << std::endl;

    }

    std::cout << "All UpstreamConnectionPool tests passed." << std::endl;

    return 0;

}