Cover the path the response takes to the verdict

The helper tests call IsBulkResponseSuccessful() directly, so they cannot
show that the status and the body reach it. A handler that stored a fixed
status, or an Export() that never asked for one, passes all of them.

Three cases through the exporter with a fake HTTP client: an accepted bulk
response, the rejected item from #4295 whose shard counter still reads
"failed" : 0, and a 500 carrying a body the parser would otherwise accept.

The fake client is the same one #4331 adds to this file. Whichever lands
first, the other drops the duplicate when it rebases.

Author: thc1006

exporters/elasticsearch/test/es_log_record_exporter_test.cc

@@ -5,7 +5,9 @@
 #include "opentelemetry/common/timestamp.h"
 #include "opentelemetry/exporters/elasticsearch/detail/es_bulk_response.h"
 #include "opentelemetry/exporters/elasticsearch/es_log_recordable.h"
+#include "opentelemetry/ext/http/client/http_client.h"
 #include "opentelemetry/logs/severity.h"
+#include "opentelemetry/nostd/function_ref.h"
 #include "opentelemetry/nostd/span.h"
 #include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/nostd/utility.h"
@@ -20,6 +22,8 @@
 #include <chrono>
 #include <cstddef>
 #include <cstdint>
+#include <functional>
+#include <memory>
 #include <string>
 #include <utility>
 #include "nlohmann/json.hpp"
@@ -251,3 +255,151 @@ TEST(ElasticsearchBulkResponseTests, DoesNotRequireItemsForSuccess)
   std::string reason;
   EXPECT_TRUE(logs_exporter::detail::IsBulkResponseSuccessful(200, R"({"errors":false})", reason));
 }
+// ---------------------------------------------------------------------------
+// The response travelling from the HTTP callback to the verdict.
+//
+// The cases above call IsBulkResponseSuccessful() directly, so they cannot show
+// that the status and the body actually reach it. A fake HTTP client drives the
+// callbacks from inside SendRequest(), which runs before Export() reaches the
+// wait, and the assertions are on the ExportResult.
+//
+// This fixture is the same one #4331 adds to this file. Whichever lands first,
+// the other drops the duplicate when it rebases.
+// ---------------------------------------------------------------------------
+namespace
+{
+namespace http_client = opentelemetry::ext::http::client;
+
+class FakeResponse : public http_client::Response
+{
+public:
+  FakeResponse(http_client::StatusCode status, const std::string &body)
+      : status_(status), body_(body.begin(), body.end())
+  {}
+  const http_client::Body &GetBody() const noexcept override { return body_; }
+  bool ForEachHeader(
+      nostd::function_ref<bool(nostd::string_view, nostd::string_view)>) const noexcept override
+  {
+    return true;
+  }
+  bool ForEachHeader(
+      const nostd::string_view &,
+      nostd::function_ref<bool(nostd::string_view, nostd::string_view)>) const noexcept override
+  {
+    return true;
+  }
+  http_client::StatusCode GetStatusCode() const noexcept override { return status_; }
+
+private:
+  http_client::StatusCode status_;
+  http_client::Body body_;
+};
+
+class FakeRequest : public http_client::Request
+{
+public:
+  void SetMethod(http_client::Method) noexcept override {}
+  void SetUri(nostd::string_view) noexcept override {}
+  void SetSslOptions(const http_client::HttpSslOptions &) noexcept override {}
+  void SetBody(http_client::Body &) noexcept override {}
+  void AddHeader(nostd::string_view, nostd::string_view) noexcept override {}
+  void ReplaceHeader(nostd::string_view, nostd::string_view) noexcept override {}
+  void SetTimeoutMs(std::chrono::milliseconds) noexcept override {}
+  void SetCompression(const http_client::Compression &) noexcept override {}
+  void EnableLogging(bool) noexcept override {}
+  void SetRetryPolicy(const http_client::RetryPolicy &) noexcept override {}
+};
+
+using EventScript = std::function<void(http_client::EventHandler &)>;
+
+class FakeSession : public http_client::Session
+{
+public:
+  explicit FakeSession(EventScript script) : script_(std::move(script)) {}
+  std::shared_ptr<http_client::Request> CreateRequest() noexcept override
+  {
+    return std::make_shared<FakeRequest>();
+  }
+  void SendRequest(std::shared_ptr<http_client::EventHandler> handler) noexcept override
+  {
+    script_(*handler);
+  }
+  bool IsSessionActive() noexcept override { return false; }
+  bool CancelSession() noexcept override { return true; }
+  bool FinishSession() noexcept override { return true; }
+
+private:
+  EventScript script_;
+};
+
+class FakeHttpClient : public http_client::HttpClient
+{
+public:
+  explicit FakeHttpClient(EventScript script) : script_(std::move(script)) {}
+  std::shared_ptr<http_client::Session> CreateSession(nostd::string_view) noexcept override
+  {
+    return std::make_shared<FakeSession>(script_);
+  }
+  bool CancelAllSessions() noexcept override { return true; }
+  bool FinishAllSessions() noexcept override { return true; }
+  void SetMaxSessionsPerConnection(std::size_t) noexcept override {}
+
+private:
+  EventScript script_;
+};
+
+opentelemetry::sdk::common::ExportResult ExportWith(EventScript script)
+{
+  auto client = std::make_shared<FakeHttpClient>(std::move(script));
+  logs_exporter::ElasticsearchExporterOptions options;
+  logs_exporter::ElasticsearchLogRecordExporter exporter(options, client);
+  auto record = exporter.MakeRecordable();
+  return exporter.Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+}
+}  // namespace
+
+// The synchronous wait exists only when the exporter is built without async export, so these cases
+// skip rather than compile out: gtest_add_tests reads the source, and a case that disappeared from
+// the binary would still be registered with CTest.
+#ifdef ENABLE_ASYNC_EXPORT
+#  define SKIP_WITHOUT_SYNC_EXPORT() \
+    GTEST_SKIP() << "Export() returns without waiting when async export is enabled"
+#else
+#  define SKIP_WITHOUT_SYNC_EXPORT() (void)0
+#endif
+
+// A body the parser accepts, through the whole path rather than through the helper alone.
+TEST(ElasticsearchLogsExporterWiringTests, AcceptedBulkResponseIsASuccessfulExport)
+{
+  SKIP_WITHOUT_SYNC_EXPORT();
+  const auto result = ExportWith([](http_client::EventHandler &handler) {
+    FakeResponse response(200, kPrettySuccess);
+    handler.OnResponse(response);
+  });
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kSuccess);
+}
+
+// The case #4295 reports: 200 with a rejected item. The shard counter in the body still reads
+// "failed" : 0, which is what the old substring check matched on, so this fails before the fix
+// and passes after it.
+TEST(ElasticsearchLogsExporterWiringTests, RejectedItemIsAFailedExport)
+{
+  SKIP_WITHOUT_SYNC_EXPORT();
+  const auto result = ExportWith([](http_client::EventHandler &handler) {
+    FakeResponse response(200, kOneItemRejected);
+    handler.OnResponse(response);
+  });
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kFailure);
+}
+
+// The status has to reach the parser, not just the body. A handler that stored a fixed status,
+// or an Export() that never asked for it, would still pass every case above.
+TEST(ElasticsearchLogsExporterWiringTests, ServerErrorIsAFailedExportEvenWithAnAcceptedBody)
+{
+  SKIP_WITHOUT_SYNC_EXPORT();
+  const auto result = ExportWith([](http_client::EventHandler &handler) {
+    FakeResponse response(500, kPrettySuccess);
+    handler.OnResponse(response);
+  });
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kFailure);
+}