Skip to content

Commit 472f73a

Browse files
Integration tests: 15kb rpc payloads (rpc v2). update rust sdk hash.
1 parent 245d55c commit 472f73a

2 files changed

Lines changed: 140 additions & 30 deletions

File tree

‎client-sdk-rust‎

‎src/tests/integration/test_rpc.cpp‎

Lines changed: 139 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -33,8 +33,9 @@ namespace livekit::test {
3333

3434
using 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
4041
struct 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+
93102
class RpcIntegrationTest : public ::testing::Test {
94103
protected:
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

Comments
 (0)