test(sdks): raise coverage across Python/JS/C#/Java/C++ SDKs

Coverage push to clear the 80% bar per SDK (local, statement/line):

- python 74% -> 94%: fake-agent harness over real sockets driving
  transport/tcp.py 48%->99% and client branches 69%->98% (TLS matrix
  included)
- js ~78% -> 97%: tcp_transport 12.7%->96.8% via an in-memory fake
  agent (framing, multiplexing, inbound dispatch, disconnects);
  invoker error/streaming matrix 78.6%->98.6%; index.ts -> 100%
- csharp 61.4% -> 94.3%: MockAgentServer + lifecycle/transport-factory
  tests lift CroupierClient to 94% and Invoker to 100%
- java 84% -> 97.4% (jacoco line): client 62%->96%, ServerHttpInvoker
  70%->95%, transport edge scripts; jacoco config added
- cpp 64.4% -> 88.1% (gcov): http_transport 0%->88%, client 55%->82%,
  dynamic_loader 48%->94% via real-socket/real-.so tests; 471 gtests

Bugs found are recorded in the task notes and left unfixed (TLS race in
python transport, C# heartbeat-loop kill on manual disconnect, java
JSON integer widening, C++ single-shot reconnect, among others).

Author: cuihairu

sdks/cpp/CMakeLists.txt

@@ -684,8 +684,30 @@ if(BUILD_TESTS)
             tests/test_plugin_manager.cpp
             tests/test_protocol.cpp
             tests/test_logger.cpp
+            tests/test_http_transport.cpp
+            tests/test_client_provider.cpp
+            tests/test_dynamic_loader_lifecycle.cpp
+            tests/test_json_schema.cpp
+            tests/test_config_generation.cpp
+            tests/test_invoker_retry.cpp
         )
 
+        # Real shared-object plugins used by the dynamic loader tests.
+        if(UNIX)
+            add_library(croupier-sample-plugin SHARED tests/plugins/sample_plugin.cpp)
+            target_include_directories(croupier-sample-plugin PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+            set_target_properties(croupier-sample-plugin PROPERTIES
+                LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/test-plugins
+                PREFIX "lib"
+            )
+            add_library(croupier-failing-init-plugin SHARED tests/plugins/failing_init_plugin.cpp)
+            target_include_directories(croupier-failing-init-plugin PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)
+            set_target_properties(croupier-failing-init-plugin PROPERTIES
+                LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/test-plugins
+                PREFIX "lib"
+            )
+        endif()
+
         add_executable(croupier-sdk-tests
             ${CROUPIER_TEST_SOURCES}
         )
@@ -695,6 +717,12 @@ if(BUILD_TESTS)
             target_compile_definitions(croupier-sdk-tests PRIVATE CROUPIER_SDK_HAS_TCP)
         endif()
 
+        if(UNIX)
+            add_dependencies(croupier-sdk-tests croupier-sample-plugin croupier-failing-init-plugin)
+            target_compile_definitions(croupier-sdk-tests PRIVATE
+                CROUPIER_TEST_PLUGIN_DIR="${CMAKE_BINARY_DIR}/test-plugins")
+        endif()
+
         if(TARGET GTest::gtest_main)
             set(_croupier_gtest_main GTest::gtest_main)
         else()

sdks/cpp/tests/plugins/failing_init_plugin.cpp

@@ -0,0 +1,24 @@
+// Test-only plugin whose croupier_plugin_init reports failure. Used to cover
+// PluginManager::InitializePlugin failure branches.
+#include "croupier/sdk/plugin/dynamic_loader.h"
+
+using namespace croupier::sdk::plugin;
+
+static PluginInfo failing_info = {
+    "failing_init_plugin",
+    "1.0.0",
+    "SDK Tests",
+    "Plugin whose init always fails",
+    {},
+    {},
+};
+
+extern "C" {
+
+int croupier_plugin_init() { return 7; }
+
+PluginInfo* croupier_plugin_info() { return &failing_info; }
+
+void croupier_plugin_cleanup() {}
+
+}  // extern "C"

sdks/cpp/tests/plugins/sample_plugin.cpp

@@ -0,0 +1,40 @@
+// Test-only sample plugin used by unit tests to exercise the dynamic loader
+// and plugin manager against a real shared object.
+#include "croupier/sdk/plugin/dynamic_loader.h"
+
+#include <string>
+
+using namespace croupier::sdk::plugin;
+
+static PluginInfo sample_info = {
+    "sample_plugin",
+    "2.1.0",
+    "SDK Tests",
+    "Plugin used by croupier-sdk-tests",
+    {"sample_echo", "sample_missing"},
+    {{"language", "C++"}},
+};
+
+static int g_init_calls = 0;
+
+extern "C" {
+
+int sample_plugin_init_calls() { return g_init_calls; }
+
+int croupier_plugin_init() {
+    ++g_init_calls;
+    return 0;
+}
+
+PluginInfo* croupier_plugin_info() { return &sample_info; }
+
+void croupier_plugin_cleanup() {}
+
+const char* sample_echo(const char* context, const char* payload) {
+    static std::string result;
+    result = std::string("{\"echo\":true,\"context\":\"") + (context ? context : "") +
+             "\",\"payload\":" + (payload ? payload : "null") + "}";
+    return result.c_str();
+}
+
+}  // extern "C"

sdks/cpp/tests/test_client_provider.cpp

@@ -0,0 +1,249 @@
+// Provider-side client lifecycle against a fake Agent built from the SDK's own
+// TCPServer: registration, heartbeats, Serve() loop, and reconnection.
+#include <gtest/gtest.h>
+#include "croupier/sdk/croupier_client.h"
+#include "croupier/sdk/tcp_transport.h"
+#include "croupier/sdk/v1/provider.pb.h"
+
+#include <atomic>
+#include <chrono>
+#include <memory>
+#include <thread>
+
+namespace croupier::sdk::test {
+namespace {
+
+using ::croupier::sdk::v1::ProviderConnectRequest;
+using ::croupier::sdk::v1::ProviderConnectResponse;
+using ::croupier::sdk::v1::ProviderHeartbeatRequest;
+
+enum class AgentMode {
+    kAccept,             // normal registration with a session id
+    kJsonError,          // respond with a JSON error document
+    kEmptySessionId,     // respond with a protobuf response lacking session_id
+};
+
+// Picks a free loopback port so a restarted fake agent rebinds the same port.
+int ReserveLoopbackPort() {
+    TCPServer probe("127.0.0.1:0");
+    probe.Start();
+    const std::string address = probe.GetListenAddress();
+    probe.Stop();
+    return std::stoi(address.substr(address.rfind(':') + 1));
+}
+
+class FakeAgent {
+public:
+    explicit FakeAgent(AgentMode mode = AgentMode::kAccept)
+        : mode_(mode), server_(/*listen_address=*/"127.0.0.1:" + std::to_string(ReserveLoopbackPort()),
+                               /*timeout_ms=*/5000) {
+        server_.SetHandler([this](uint32_t msg_type, uint32_t /*req_id*/, const std::vector<uint8_t>& body) {
+            if (msg_type == protocol::MSG_PROVIDER_CONNECT_REQUEST) {
+                ++connect_requests_;
+                ProviderConnectRequest request;
+                (void)request.ParseFromArray(body.data(), static_cast<int>(body.size()));
+                last_service_id_ = request.service_id();
+                last_function_count_ = static_cast<int>(request.functions_size());
+
+                if (mode_ == AgentMode::kJsonError) {
+                    const std::string json_error = R"({"error":"rejected"})";
+                    return std::vector<uint8_t>(json_error.begin(), json_error.end());
+                }
+                ProviderConnectResponse response;
+                if (mode_ == AgentMode::kAccept) {
+                    response.set_session_id("session-42");
+                }
+                std::string out;
+                response.SerializeToString(&out);
+                return std::vector<uint8_t>(out.begin(), out.end());
+            }
+            if (msg_type == protocol::MSG_PROVIDER_HEARTBEAT_REQUEST) {
+                ++heartbeats_;
+                ProviderHeartbeatRequest request;
+                (void)request.ParseFromArray(body.data(), static_cast<int>(body.size()));
+                last_heartbeat_session_ = request.session_id();
+                return std::vector<uint8_t>{};
+            }
+            return std::vector<uint8_t>{};
+        });
+        server_.Start();
+    }
+
+    ~FakeAgent() { server_.Stop(); }
+
+    std::string address() const { return server_.GetListenAddress(); }
+    int port() const {
+        const size_t colon = address().rfind(':');
+        return std::stoi(address().substr(colon + 1));
+    }
+    int heartbeats() const { return heartbeats_; }
+    int connect_requests() const { return connect_requests_; }
+    const std::string& last_service_id() const { return last_service_id_; }
+    const std::string& last_heartbeat_session() const { return last_heartbeat_session_; }
+    int last_function_count() const { return last_function_count_; }
+
+    void stop() { server_.Stop(); }
+    void restart() { server_.Start(); }
+
+private:
+    AgentMode mode_;
+    TCPServer server_;
+    std::atomic<int> heartbeats_{0};
+    std::atomic<int> connect_requests_{0};
+    std::string last_service_id_;
+    std::string last_heartbeat_session_;
+    std::atomic<int> last_function_count_{0};
+};
+
+ClientConfig ProviderConfig(const std::string& agent_addr, int heartbeat_interval = 1) {
+    ClientConfig config;
+    config.game_id = "game-test";
+    config.env = "development";
+    config.service_id = "cpp-tests";
+    config.agent_addr = agent_addr;
+    config.timeout_seconds = 5;
+    config.connect_timeout_seconds = 2;
+    config.heartbeat_interval = heartbeat_interval;
+    config.disable_logging = true;
+    return config;
+}
+
+void RegisterSampleFunction(CroupierClient& client) {
+    FunctionDescriptor desc;
+    desc.id = "test.echo";
+    desc.version = "1.4.2";
+    desc.summary = "echo payload";
+    desc.operation = "echo";
+    desc.capability = "action";
+    desc.risk = "safe";
+    FunctionHandler handler = [](const std::string&, const std::string& payload) { return payload; };
+    ASSERT_TRUE(client.RegisterFunction(desc, handler));
+}
+
+TEST(ProviderLifecycleTest, ConnectRegistersFunctionsAndReceivesSession) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address(), /*heartbeat_interval=*/60));
+    RegisterSampleFunction(client);
+
+    EXPECT_FALSE(client.IsConnected());
+    ASSERT_TRUE(client.Connect());
+    EXPECT_TRUE(client.IsConnected());
+    ASSERT_EQ(1, agent.connect_requests());
+    EXPECT_EQ("cpp-tests", agent.last_service_id());
+    ASSERT_EQ(1, agent.last_function_count());
+    client.Stop();
+    EXPECT_FALSE(client.IsConnected());
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+}
+
+TEST(ProviderLifecycleTest, ConnectWithoutRegisteredFunctionsFails) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address()));
+    EXPECT_FALSE(client.Connect());
+    EXPECT_EQ(0, agent.connect_requests());
+}
+
+TEST(ProviderLifecycleTest, AgentJsonErrorFailsRegistration) {
+    FakeAgent agent(AgentMode::kJsonError);
+    CroupierClient client(ProviderConfig(agent.address()));
+    RegisterSampleFunction(client);
+    EXPECT_FALSE(client.Connect());
+    EXPECT_FALSE(client.IsConnected());
+}
+
+TEST(ProviderLifecycleTest, EmptySessionIdFailsRegistration) {
+    FakeAgent agent(AgentMode::kEmptySessionId);
+    CroupierClient client(ProviderConfig(agent.address()));
+    RegisterSampleFunction(client);
+    EXPECT_FALSE(client.Connect());
+    EXPECT_FALSE(client.IsConnected());
+}
+
+TEST(ProviderLifecycleTest, DoubleConnectIsIdempotent) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address(), /*heartbeat_interval=*/60));
+    RegisterSampleFunction(client);
+    ASSERT_TRUE(client.Connect());
+    ASSERT_TRUE(client.Connect());
+    EXPECT_EQ(1, agent.connect_requests());
+    client.Stop();
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+}
+
+TEST(ProviderLifecycleTest, HeartbeatSendsSessionId) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address(), /*heartbeat_interval=*/1));
+    RegisterSampleFunction(client);
+    ASSERT_TRUE(client.Connect());
+
+    // Wait until at least one heartbeat reached the fake agent (bounded).
+    for (int i = 0; i < 100 && agent.heartbeats() < 1; ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    EXPECT_GE(agent.heartbeats(), 1);
+    EXPECT_EQ("session-42", agent.last_heartbeat_session());
+
+    client.Stop();
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+}
+
+TEST(ProviderLifecycleTest, ServeRunsUntilStop) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address(), /*heartbeat_interval=*/60));
+    RegisterSampleFunction(client);
+
+    std::thread serve_thread([&client] { client.Serve(); });
+    for (int i = 0; i < 100 && !client.IsConnected(); ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    ASSERT_TRUE(client.IsConnected());
+
+    client.Stop();
+    serve_thread.join();
+    EXPECT_FALSE(client.IsConnected());
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+}
+
+TEST(ProviderLifecycleTest, ReconnectsAfterAgentRestart) {
+    FakeAgent agent;
+    ClientConfig config = ProviderConfig(agent.address(), /*heartbeat_interval=*/1);
+    config.timeout_seconds = 1;  // fail fast so heartbeat errors surface quickly
+    CroupierClient client(config);
+    RegisterSampleFunction(client);
+    ASSERT_TRUE(client.Connect());
+    EXPECT_EQ(1, agent.connect_requests());
+
+    // Kill and immediately restart the agent on the same port. The client's
+    // existing TCP session dies, so the next heartbeat fails and triggers a
+    // reconnect, which can succeed because the listener is already back.
+    // NOTE (recorded bug): after one failed reconnect attempt the client
+    // stops retrying (Connect() failure sets should_stop_heartbeat_, which
+    // terminates reconnectLoop), so a slower agent restart would never
+    // recover.
+    agent.stop();
+    agent.restart();
+
+    bool reconnected = false;
+    for (int i = 0; i < 300 && !reconnected; ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        reconnected = client.IsConnected() && agent.connect_requests() >= 2;
+    }
+    EXPECT_TRUE(reconnected);
+    EXPECT_GE(agent.connect_requests(), 2);
+
+    client.Stop();
+    std::this_thread::sleep_for(std::chrono::milliseconds(200));
+}
+
+TEST(ProviderLifecycleTest, CloseClearsState) {
+    FakeAgent agent;
+    CroupierClient client(ProviderConfig(agent.address(), /*heartbeat_interval=*/60));
+    RegisterSampleFunction(client);
+    ASSERT_TRUE(client.Connect());
+    client.Close();
+    EXPECT_FALSE(client.IsConnected());
+    std::this_thread::sleep_for(std::chrono::milliseconds(150));
+}
+
+}  // namespace
+}  // namespace croupier::sdk::test