[TEST] Hold what a client without a multi handle does with a request

Reporting the curl_multi_init failure does not by itself stop the client taking
requests, so the case now holds what taking one leads to rather than only that
the failure was reported. Raised by @lalitb in review.

Measured before choosing an assertion. A client built on a null multi handle
answers normally: curl_multi_perform rejects the handle, the IO loop resets it,
the pending session moves to the new one and the request completes, three runs
out of three with the internal log confirming the handle really was null. Gate
resetMultiHandle out and the same case fails on the new assertion and then hangs,
which is the outcome the assertion exists to catch.

So the case asserts the caller reaches a terminal outcome and the session does
not stay active, without pinning which outcome. A build where the allocation is
still failing when the reset runs reports a failure instead of a response, and
both satisfy the property that matters.

Signed-off-by: thc1006 <84045975+thc1006@users.noreply.github.com>

Author: thc1006

ext/test/http/curl_http_test.cc

@@ -285,6 +285,35 @@ struct FailCurlCalloc
   FailCurlCalloc &operator=(FailCurlCalloc &&)      = delete;
 };
 
+// Counts terminal outcomes without caring which one, since a client whose multi handle could
+// not be created may still recover and answer, and the case below is about the caller being
+// told either way rather than about which answer it gets.
+class MultiHandleOutcomeHandler : public http_client::EventHandler
+{
+public:
+  void OnResponse(http_client::Response & /* response */) noexcept override
+  {
+    terminal_.fetch_add(1, std::memory_order_release);
+  }
+
+  void OnEvent(http_client::SessionState state, nostd::string_view /* reason */) noexcept override
+  {
+    switch (state)
+    {
+      case http_client::SessionState::CreateFailed:
+      case http_client::SessionState::ConnectFailed:
+      case http_client::SessionState::SendFailed:
+      case http_client::SessionState::Cancelled:
+        terminal_.fetch_add(1, std::memory_order_release);
+        break;
+      default:
+        break;
+    }
+  }
+
+  std::atomic<int> terminal_{0};
+};
+
 class CapturingLogHandler : public opentelemetry::sdk::common::internal_log::LogHandler
 {
 public:
@@ -965,6 +994,48 @@ TEST_F(BasicCurlHttpTests, AFailedMultiHandleAllocationIsReported)
       << "a multi handle that could not be created was not reported, captured: " << text;
 }
 
+// Reporting the failure does not by itself stop the client taking requests, so this holds what
+// taking one leads to. The IO loop resets the multi handle whenever curl_multi_perform rejects
+// it, so a client built on a null handle repairs itself and answers; if the allocation is still
+// failing by then it reports a failure instead. What must not happen is neither.
+TEST_F(BasicCurlHttpTests, AClientWithoutAMultiHandleStillAnswers)
+{
+  ASSERT_TRUE(g_curl_hooks_installed);
+  received_requests_.clear();
+
+  {
+    auto warmup = std::make_shared<http_client::curl::HttpCurlClientFactory>()->Create();
+    ASSERT_TRUE(warmup != nullptr);
+    warmup->FinishAllSessions();
+  }
+
+  std::shared_ptr<http_client::HttpClient> client;
+  {
+    FailCurlCalloc fail;
+    client = std::make_shared<http_client::curl::HttpCurlClientFactory>()->Create();
+  }
+  ASSERT_TRUE(client != nullptr);
+
+  auto session = client->CreateSession("http://127.0.0.1:19000");
+  auto request = session->CreateRequest();
+  request->SetUri("get/");
+
+  auto handler = std::make_shared<MultiHandleOutcomeHandler>();
+  session->SendRequest(handler);
+
+  for (int i = 0; i < 300 && 0 == handler->terminal_.load(std::memory_order_acquire); ++i)
+  {
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+
+  EXPECT_GE(handler->terminal_.load(std::memory_order_acquire), 1)
+      << "the request was accepted and never reached an outcome";
+  EXPECT_FALSE(session->IsSessionActive()) << "the session stayed active with nothing running it";
+
+  session->FinishSession();
+  client->FinishAllSessions();
+}
+
 TEST_F(BasicCurlHttpTests, SendGetRequestSync)
 {
   received_requests_.clear();