@@ -33,8 +33,9 @@ namespace livekit::test {
3333
3434using namespace std ::chrono_literals;
3535
36- // Maximum RPC payload size (15KB)
37- constexpr size_t kMaxRpcPayloadSize = 15 * 1024 ;
36+ // RPC v1 packet payload limit was 15 KB; v2 data streams must exceed it.
37+ constexpr size_t kRpcV1PayloadLimit = 15 * 1024 ;
38+ constexpr size_t kLargeRpcPayloadSize = 20 * 1000 ;
3839
3940// Test configuration from environment variables
4041struct RpcTestConfig {
@@ -90,6 +91,14 @@ std::string generateRandomPayload(size_t size) {
9091 return result.substr (0 , size);
9192}
9293
94+ size_t checksumPayload (const std::string& payload) {
95+ size_t checksum = 0 ;
96+ for (char c : payload) {
97+ checksum += static_cast <unsigned char >(c);
98+ }
99+ return checksum;
100+ }
101+
93102class RpcIntegrationTest : public ::testing::Test {
94103protected:
95104 void SetUp () override {
@@ -121,14 +130,22 @@ TEST_F(RpcIntegrationTest, BasicRpcRoundTrip) {
121130 // Register RPC handler on receiver - returns size and checksum instead of
122131 // full payload
123132 std::atomic<int > rpc_calls_received{0 };
133+ std::string caller_identity;
134+ std::string observed_request_id;
135+ std::string observed_caller_identity;
136+ double observed_response_timeout = 0.0 ;
137+ std::mutex observed_mutex;
124138 lockLocalParticipant (*receiver_room)
125- ->registerRpcMethod (" echo" , [&rpc_calls_received ](const RpcInvocationData& data) -> std::optional<std::string> {
139+ ->registerRpcMethod (" echo" , [&](const RpcInvocationData& data) -> std::optional<std::string> {
126140 rpc_calls_received++;
127- size_t checksum = 0 ;
128- for (char c : data.payload ) {
129- checksum += static_cast <unsigned char >(c);
141+ {
142+ const std::scoped_lock<std::mutex> lock (observed_mutex);
143+ observed_request_id = data.request_id ;
144+ observed_caller_identity = data.caller_identity ;
145+ observed_response_timeout = data.response_timeout_sec ;
130146 }
131- return " echo:" + std::to_string (data.payload .size ()) + " :" + std::to_string (checksum);
147+ EXPECT_EQ (data.payload , " hello world" );
148+ return " echo:" + std::to_string (data.payload .size ()) + " :" + std::to_string (checksumPayload (data.payload ));
132149 });
133150
134151 // Create caller room
@@ -138,6 +155,7 @@ TEST_F(RpcIntegrationTest, BasicRpcRoundTrip) {
138155
139156 bool caller_connected = caller_room->connect (config_.url , config_.token_a , caller_options);
140157 ASSERT_TRUE (caller_connected) << " Caller failed to connect" ;
158+ caller_identity = lockLocalParticipant (*caller_room)->identity ();
141159
142160 // Wait for receiver to be visible to caller
143161 bool receiver_visible = waitForParticipant (caller_room.get (), receiver_identity, 10s);
@@ -148,23 +166,69 @@ TEST_F(RpcIntegrationTest, BasicRpcRoundTrip) {
148166 std::string response = lockLocalParticipant (*caller_room)->performRpc (receiver_identity, " echo" , test_payload, 10.0 );
149167
150168 // Verify response contains correct size and checksum
151- size_t expected_checksum = 0 ;
152- for (char c : test_payload) {
153- expected_checksum += static_cast <unsigned char >(c);
154- }
155169 std::string expected_response =
156- " echo:" + std::to_string (test_payload.size ()) + " :" + std::to_string (expected_checksum );
170+ " echo:" + std::to_string (test_payload.size ()) + " :" + std::to_string (checksumPayload (test_payload) );
157171 EXPECT_EQ (response, expected_response);
158172 EXPECT_EQ (rpc_calls_received.load (), 1 );
173+ {
174+ const std::scoped_lock<std::mutex> lock (observed_mutex);
175+ EXPECT_FALSE (observed_request_id.empty ());
176+ EXPECT_EQ (observed_caller_identity, caller_identity);
177+ EXPECT_GT (observed_response_timeout, 0.0 );
178+ EXPECT_LE (observed_response_timeout, 10.0 );
179+ }
159180
160181 // Cleanup
161182 lockLocalParticipant (*receiver_room)->unregisterRpcMethod (" echo" );
162183 caller_room.reset ();
163184 receiver_room.reset ();
164185}
165186
166- // Test maximum payload size (15KB)
167- TEST_F (RpcIntegrationTest, MaxPayloadSize) {
187+ TEST_F (RpcIntegrationTest, LargeRequestPayloadRoundTrip) {
188+ if (!config_.available ) {
189+ GTEST_SKIP () << " LIVEKIT_URL, LIVEKIT_TOKEN_A, and LIVEKIT_TOKEN_B not set" ;
190+ }
191+
192+ auto receiver_room = std::make_unique<Room>();
193+ RoomOptions options;
194+ options.auto_subscribe = true ;
195+
196+ bool receiver_connected = receiver_room->connect (config_.url , config_.token_b , options);
197+ ASSERT_TRUE (receiver_connected) << " Receiver failed to connect" ;
198+
199+ std::string receiver_identity = lockLocalParticipant (*receiver_room)->identity ();
200+
201+ std::atomic<size_t > received_payload_size{0 };
202+ std::atomic<size_t > received_payload_checksum{0 };
203+ lockLocalParticipant (*receiver_room)
204+ ->registerRpcMethod (" large-request" , [&](const RpcInvocationData& data) -> std::optional<std::string> {
205+ received_payload_size = data.payload .size ();
206+ received_payload_checksum = checksumPayload (data.payload );
207+ return std::to_string (data.payload .size ()) + " :" + std::to_string (checksumPayload (data.payload ));
208+ });
209+
210+ auto caller_room = std::make_unique<Room>();
211+ bool caller_connected = caller_room->connect (config_.url , config_.token_a , options);
212+ ASSERT_TRUE (caller_connected) << " Caller failed to connect" ;
213+
214+ bool receiver_visible = waitForParticipant (caller_room.get (), receiver_identity, 10s);
215+ ASSERT_TRUE (receiver_visible) << " Receiver not visible to caller" ;
216+
217+ std::string max_payload = generateRandomPayload (kLargeRpcPayloadSize );
218+ ASSERT_GT (max_payload.size (), kRpcV1PayloadLimit );
219+ std::string response =
220+ lockLocalParticipant (*caller_room)->performRpc (receiver_identity, " large-request" , max_payload, 30.0 );
221+
222+ EXPECT_EQ (response, std::to_string (kLargeRpcPayloadSize ) + " :" + std::to_string (checksumPayload (max_payload)));
223+ EXPECT_EQ (received_payload_size.load (), kLargeRpcPayloadSize );
224+ EXPECT_EQ (received_payload_checksum.load (), checksumPayload (max_payload));
225+
226+ lockLocalParticipant (*receiver_room)->unregisterRpcMethod (" large-request" );
227+ caller_room.reset ();
228+ receiver_room.reset ();
229+ }
230+
231+ TEST_F (RpcIntegrationTest, LargeResponsePayloadRoundTrip) {
168232 if (!config_.available ) {
169233 GTEST_SKIP () << " LIVEKIT_URL, LIVEKIT_TOKEN_A, and LIVEKIT_TOKEN_B not set" ;
170234 }
@@ -177,11 +241,13 @@ TEST_F(RpcIntegrationTest, MaxPayloadSize) {
177241 ASSERT_TRUE (receiver_connected) << " Receiver failed to connect" ;
178242
179243 std::string receiver_identity = lockLocalParticipant (*receiver_room)->identity ();
244+ const std::string large_response = generateRandomPayload (kLargeRpcPayloadSize );
245+ ASSERT_GT (large_response.size (), kRpcV1PayloadLimit );
180246
181- // Register handler that echoes payload size
182247 lockLocalParticipant (*receiver_room)
183- ->registerRpcMethod (" payload-size" , [](const RpcInvocationData& data) -> std::optional<std::string> {
184- return std::to_string (data.payload .size ());
248+ ->registerRpcMethod (" large-response" , [&](const RpcInvocationData& data) -> std::optional<std::string> {
249+ EXPECT_EQ (data.payload , " send-large-response" );
250+ return large_response;
185251 });
186252
187253 auto caller_room = std::make_unique<Room>();
@@ -191,14 +257,58 @@ TEST_F(RpcIntegrationTest, MaxPayloadSize) {
191257 bool receiver_visible = waitForParticipant (caller_room.get (), receiver_identity, 10s);
192258 ASSERT_TRUE (receiver_visible) << " Receiver not visible to caller" ;
193259
194- // Test with max payload size (15KB)
195- std::string max_payload = generateRandomPayload (kMaxRpcPayloadSize );
196260 std::string response =
197- lockLocalParticipant (*caller_room)->performRpc (receiver_identity, " payload-size" , max_payload, 30.0 );
261+ lockLocalParticipant (*caller_room)->performRpc (receiver_identity, " large-response" , " send-large-response" , 30.0 );
262+
263+ EXPECT_EQ (response.size (), large_response.size ());
264+ EXPECT_EQ (checksumPayload (response), checksumPayload (large_response));
265+ EXPECT_EQ (response, large_response);
266+
267+ lockLocalParticipant (*receiver_room)->unregisterRpcMethod (" large-response" );
268+ caller_room.reset ();
269+ receiver_room.reset ();
270+ }
271+
272+ TEST_F (RpcIntegrationTest, LargeRequestAndResponseRoundTrip) {
273+ if (!config_.available ) {
274+ GTEST_SKIP () << " LIVEKIT_URL, LIVEKIT_TOKEN_A, and LIVEKIT_TOKEN_B not set" ;
275+ }
276+
277+ auto receiver_room = std::make_unique<Room>();
278+ RoomOptions options;
279+ options.auto_subscribe = true ;
280+
281+ bool receiver_connected = receiver_room->connect (config_.url , config_.token_b , options);
282+ ASSERT_TRUE (receiver_connected) << " Receiver failed to connect" ;
283+
284+ std::string receiver_identity = lockLocalParticipant (*receiver_room)->identity ();
285+ const std::string large_response = generateRandomPayload (kLargeRpcPayloadSize + 123 );
286+ ASSERT_GT (large_response.size (), kRpcV1PayloadLimit );
287+
288+ lockLocalParticipant (*receiver_room)
289+ ->registerRpcMethod (" large-both" , [&](const RpcInvocationData& data) -> std::optional<std::string> {
290+ EXPECT_GT (data.payload .size (), kRpcV1PayloadLimit );
291+ return large_response;
292+ });
293+
294+ auto caller_room = std::make_unique<Room>();
295+ bool caller_connected = caller_room->connect (config_.url , config_.token_a , options);
296+ ASSERT_TRUE (caller_connected) << " Caller failed to connect" ;
297+
298+ bool receiver_visible = waitForParticipant (caller_room.get (), receiver_identity, 10s);
299+ ASSERT_TRUE (receiver_visible) << " Receiver not visible to caller" ;
300+
301+ const std::string large_request = generateRandomPayload (kLargeRpcPayloadSize );
302+ ASSERT_GT (large_request.size (), kRpcV1PayloadLimit );
303+
304+ std::string response =
305+ lockLocalParticipant (*caller_room)->performRpc (receiver_identity, " large-both" , large_request, 30.0 );
198306
199- EXPECT_EQ (response, std::to_string (kMaxRpcPayloadSize ));
307+ EXPECT_EQ (response.size (), large_response.size ());
308+ EXPECT_EQ (checksumPayload (response), checksumPayload (large_response));
309+ EXPECT_EQ (response, large_response);
200310
201- lockLocalParticipant (*receiver_room)->unregisterRpcMethod (" payload-size " );
311+ lockLocalParticipant (*receiver_room)->unregisterRpcMethod (" large-both " );
202312 caller_room.reset ();
203313 receiver_room.reset ();
204314}
@@ -333,10 +443,9 @@ TEST_F(RpcIntegrationTest, ConcurrentRpcCalls) {
333443 std::atomic<int > calls_processed{0 };
334444 lockLocalParticipant (*receiver_room)
335445 ->registerRpcMethod (" counter" , [&calls_processed](const RpcInvocationData& data) -> std::optional<std::string> {
336- int id = std::stoi (data.payload );
337446 calls_processed++;
338447 std::this_thread::sleep_for (100ms); // Simulate some work
339- return std::to_string (id * 2 ) ;
448+ return data. payload + " :handled " ;
340449 });
341450
342451 auto caller_room = std::make_unique<Room>();
@@ -350,7 +459,7 @@ TEST_F(RpcIntegrationTest, ConcurrentRpcCalls) {
350459 // it cannot expire mid-call while RPCs are in flight.
351460 ASSERT_NO_THROW (lockLocalParticipant (*caller_room));
352461
353- const int num_concurrent_calls = 10 ;
462+ const int num_concurrent_calls = 5 ;
354463 std::vector<std::thread> threads;
355464 std::atomic<int > successful_calls{0 };
356465
@@ -359,9 +468,10 @@ TEST_F(RpcIntegrationTest, ConcurrentRpcCalls) {
359468 try {
360469 auto caller_lp = lockLocalParticipant (*caller_room);
361470 ASSERT_NE (caller_lp, nullptr );
362- std::string response = caller_lp->performRpc (receiver_identity, " counter" , std::to_string (i), 30.0 );
363- int expected = i * 2 ;
364- if (std::stoi (response) == expected) {
471+ const std::string payload =
472+ " call-" + std::to_string (i) + " :" + std::string (256 + i, static_cast <char >(' a' + i));
473+ std::string response = caller_lp->performRpc (receiver_identity, " counter" , payload, 30.0 );
474+ if (response == payload + " :handled" ) {
365475 successful_calls++;
366476 }
367477 } catch (const std::exception& e) {
@@ -429,7 +539,7 @@ TEST_F(RpcIntegrationTest, OneMinuteIntegration) {
429539
430540 // Sender thread
431541 std::thread sender ([&]() {
432- std::vector<size_t > payload_sizes = {100 , 1024 , 5 * 1024 , 10 * 1024 , kMaxRpcPayloadSize };
542+ std::vector<size_t > payload_sizes = {100 , 1024 , 5 * 1024 , 10 * 1024 , kRpcV1PayloadLimit };
433543 int size_index = 0 ;
434544
435545 while (running.load ()) {
0 commit comments