more seperated test artifacts

Author: stephen-derosa

src/tests/common/remote_data_track_test_access.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2026 LiveKit
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <livekit/data_track_info.h>
+#include <livekit/remote_data_track.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "data_track.pb.h"
+
+namespace livekit {
+
+struct RemoteDataTrackTestAccess {
+  static uintptr_t ffiHandleId(const RemoteDataTrack& track) noexcept { return track.ffiHandleId(); }
+
+  static std::shared_ptr<RemoteDataTrack> create(DataTrackInfo info, std::string publisher_identity) {
+    proto::OwnedRemoteDataTrack owned;
+    owned.mutable_handle()->set_id(0);
+    auto* proto_info = owned.mutable_info();
+    proto_info->set_name(std::move(info.name));
+    proto_info->set_sid(std::move(info.sid));
+    proto_info->set_uses_e2ee(info.uses_e2ee);
+    owned.set_publisher_identity(std::move(publisher_identity));
+    return std::shared_ptr<RemoteDataTrack>(new RemoteDataTrack(owned));
+  }
+};
+
+} // namespace livekit

src/tests/integration/test_data_track.cpp

@@ -29,6 +29,7 @@
 #include <exception>
 #include <future>
 
+#include "../common/remote_data_track_test_access.h"
 #include "../common/test_common.h"
 #include "ffi_client.h"
 
@@ -782,8 +783,8 @@ TEST_F(DataTrackE2ETest, FfiClientSubscribeDataTrackReturnsSyncResult) {
     EXPECT_EQ(remote_track->info().name, expected_name);
 
     const auto subscribe_start = std::chrono::steady_clock::now();
-    auto subscribe_result =
-        FfiClient::instance().subscribeDataTrack(static_cast<std::uint64_t>(remote_track->testFfiHandleId()));
+    auto subscribe_result = FfiClient::instance().subscribeDataTrack(
+        static_cast<std::uint64_t>(RemoteDataTrackTestAccess::ffiHandleId(*remote_track)));
     const auto subscribe_elapsed = std::chrono::steady_clock::now() - subscribe_start;
     const auto subscribe_elapsed_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(subscribe_elapsed).count();
 

src/tests/unit/test_subscription_thread_dispatcher.cpp

@@ -30,6 +30,8 @@
 #include <unordered_map>
 #include <vector>
 
+#include "../common/remote_data_track_test_access.h"
+
 namespace livekit {
 
 namespace {
@@ -636,10 +638,10 @@ TEST_F(SubscriptionThreadDispatcherTest, DuplicateSubscribeWithSameVideoSidDoesN
 TEST_F(SubscriptionThreadDispatcherTest, DuplicateDataPublishWithSameSidDoesNotRestartReader) {
   SubscriptionThreadDispatcher dispatcher;
   auto reader = std::make_shared<ActiveDataReader>();
-  reader->remote_track = RemoteDataTrack::createForTest({"foo", "TR_data_1", false}, "alice");
+  reader->remote_track = RemoteDataTrackTestAccess::create({"foo", "TR_data_1", false}, "alice");
   activeDataReaders(dispatcher)[7] = reader;
 
-  auto incoming = RemoteDataTrack::createForTest({"foo", "TR_data_1", false}, "alice");
+  auto incoming = RemoteDataTrackTestAccess::create({"foo", "TR_data_1", false}, "alice");
   auto old_thread = startDataReader(dispatcher, 7, DataCallbackKey{"alice", "foo"}, incoming);
 
   EXPECT_FALSE(old_thread.joinable());
@@ -651,12 +653,12 @@ TEST_F(SubscriptionThreadDispatcherTest, DuplicateDataPublishWithSameSidDoesNotR
 TEST_F(SubscriptionThreadDispatcherTest, RepublishWithNewDataSidStopsPreviousReader) {
   SubscriptionThreadDispatcher dispatcher;
   auto previous = std::make_shared<ActiveDataReader>();
-  previous->remote_track = RemoteDataTrack::createForTest({"foo", "TR_data_1", false}, "alice");
+  previous->remote_track = RemoteDataTrackTestAccess::create({"foo", "TR_data_1", false}, "alice");
   activeDataReaders(dispatcher)[7] = previous;
 
   // A republish under the same (participant, name) but a NEW SID must stop the
   // previous reader and start a fresh one.
-  auto republished = RemoteDataTrack::createForTest({"foo", "TR_data_2", false}, "alice");
+  auto republished = RemoteDataTrackTestAccess::create({"foo", "TR_data_2", false}, "alice");
   auto old_thread = startDataReader(dispatcher, 7, DataCallbackKey{"alice", "foo"}, republished);
   if (old_thread.joinable()) {
     old_thread.join();