dsh-agora 0.2.0

package/assets/agora/references/server-gateway/linux-cpp.md

@@ -0,0 +1,251 @@
+# Server Gateway SDK — Linux C++
+
+## Initialization
+
+```cpp
+// Create and initialize IAgoraService — one instance per process
+auto service = createAgoraService();
+agora::base::AgoraServiceConfiguration scfg;
+scfg.appId = appid;
+scfg.enableAudioProcessor = true;
+scfg.enableAudioDevice = false;  // servers don't use audio devices
+scfg.enableVideo = true;
+scfg.useStringUid = false;  // set true to use string UIDs
+if (service->initialize(scfg) != agora::ERR_OK) {
+    return nullptr;
+}
+```
+
+## Create and Connect
+
+```cpp
+// Create connection — autoSubscribe must be false; set BROADCASTER role
+agora::rtc::RtcConnectionConfiguration ccfg;
+ccfg.autoSubscribeAudio = false;
+ccfg.autoSubscribeVideo = false;
+ccfg.clientRoleType = agora::rtc::CLIENT_ROLE_BROADCASTER;
+agora::agora_refptr<agora::rtc::IRtcConnection> connection =
+    service->createRtcConnection(ccfg);
+
+// Register connection observer before connecting
+auto connObserver = std::make_shared<SampleConnectionObserver>();
+connection->registerObserver(connObserver.get());
+
+// Connect to channel
+if (connection->connect(appId, channelId, userId)) {
+    AG_LOG(ERROR, "Failed to connect to Agora channel!");
+    return -1;
+}
+```
+
+## Sending Media
+
+### Create senders
+
+```cpp
+agora::agora_refptr<agora::rtc::IMediaNodeFactory> factory =
+    service->createMediaNodeFactory();
+
+// PCM audio sender
+agora::agora_refptr<agora::rtc::IAudioPcmDataSender> audioPcmDataSender =
+    factory->createAudioPcmDataSender();
+
+// YUV video sender
+agora::agora_refptr<agora::rtc::IVideoFrameSender> videoFrameSender =
+    factory->createVideoFrameSender();
+
+// Encoded audio sender (AAC, Opus, etc.)
+agora::agora_refptr<agora::rtc::IAudioEncodedFrameSender> audioFrameSender =
+    factory->createAudioEncodedFrameSender();
+
+// Encoded video sender (H.264, etc.)
+agora::agora_refptr<agora::rtc::IVideoEncodedImageSender> videoEncodedFrameSender =
+    factory->createVideoEncodedImageSender();
+```
+
+### Create and publish tracks
+
+```cpp
+// PCM audio track
+agora::agora_refptr<agora::rtc::ILocalAudioTrack> customAudioTrack =
+    service->createCustomAudioTrack(audioPcmDataSender);
+
+// Encoded audio track
+agora::agora_refptr<agora::rtc::ILocalAudioTrack> customAudioTrack =
+    service->createCustomAudioTrack(audioFrameSender, agora::base::MIX_DISABLED);
+
+// YUV video track
+agora::agora_refptr<agora::rtc::ILocalVideoTrack> customVideoTrack =
+    service->createCustomVideoTrack(videoFrameSender);
+
+// Encoded video track
+agora::agora_refptr<agora::rtc::ILocalVideoTrack> customVideoTrack =
+    service->createCustomVideoTrack(videoEncodedFrameSender);
+
+// Enable and publish
+customAudioTrack->setEnabled(true);
+connection->getLocalUser()->publishAudio(customAudioTrack);
+customVideoTrack->setEnabled(true);
+connection->getLocalUser()->publishVideo(customVideoTrack);
+```
+
+### Send PCM audio (10 ms intervals — required)
+
+```cpp
+// PCM must be sent in exactly 10 ms frames — use a pacer thread
+static void SampleSendAudioTask(
+    agora::agora_refptr<agora::rtc::IAudioPcmDataSender> audioFrameSender,
+    bool& exitFlag) {
+    PacerInfo pacer = {0, 10, std::chrono::steady_clock::now()};
+    while (!exitFlag) {
+        // samplesPer10ms = sampleRate / 100
+        audioFrameSender->sendAudioPcmData(
+            frameBuf, 0, samplesPer10ms,
+            agora::rtc::TWO_BYTES_PER_SAMPLE,
+            numOfChannels, sampleRate);
+        waitBeforeNextSend(pacer);
+    }
+}
+```
+
+### Send encoded H.264 video
+
+```cpp
+static void sendOneH264Frame(
+    int frameRate,
+    std::unique_ptr<HelperH264Frame> h264Frame,
+    agora::agora_refptr<agora::rtc::IVideoEncodedImageSender> videoH264FrameSender) {
+    agora::rtc::EncodedVideoFrameInfo videoEncodedFrameInfo;
+    videoEncodedFrameInfo.rotation = agora::rtc::VIDEO_ORIENTATION_0;
+    videoEncodedFrameInfo.codecType = agora::rtc::VIDEO_CODEC_H264;
+    videoEncodedFrameInfo.framesPerSecond = frameRate;
+    videoEncodedFrameInfo.frameType =
+        h264Frame->isKeyFrame
+            ? agora::rtc::VIDEO_FRAME_TYPE_KEY_FRAME
+            : agora::rtc::VIDEO_FRAME_TYPE_DELTA_FRAME;
+
+    videoH264FrameSender->sendEncodedVideoImage(
+        reinterpret_cast<uint8_t*>(h264Frame->buffer.get()),
+        h264Frame->bufferLen,
+        videoEncodedFrameInfo);
+}
+```
+
+## Receiving Media
+
+```cpp
+// Register observers via SampleLocalUserObserver (wraps ILocalUserObserver)
+auto localUserObserver =
+    std::make_shared<SampleLocalUserObserver>(connection->getLocalUser());
+
+// Audio: set PCM params before registering observer
+connection->getLocalUser()->setPlaybackAudioFrameBeforeMixingParameters(
+    numOfChannels, sampleRate);
+
+auto pcmFrameObserver = std::make_shared<PcmFrameObserver>(outputFile);
+localUserObserver->setAudioFrameObserver(pcmFrameObserver.get());
+
+// Video (encoded H.264)
+auto h264FrameReceiver = std::make_shared<H264FrameReceiver>(outputFile);
+localUserObserver->setVideoEncodedImageReceiver(h264FrameReceiver.get());
+```
+
+### PCM receive callback
+
+```cpp
+bool PcmFrameObserver::onPlaybackAudioFrameBeforeMixing(
+    const char* channelId,
+    agora::media::base::user_id_t userId,
+    AudioFrame& audioFrame) {
+    size_t writeBytes =
+        audioFrame.samplesPerChannel * audioFrame.channels * sizeof(int16_t);
+    fwrite(audioFrame.buffer, 1, writeBytes, pcmFile_);
+    return true;
+}
+```
+
+### Encoded video receive callback
+
+```cpp
+class H264FrameReceiver : public agora::rtc::IVideoEncodedImageReceiver {
+public:
+    bool OnEncodedVideoImageReceived(
+        const uint8_t* imageBuffer,
+        size_t length,
+        const agora::rtc::EncodedVideoFrameInfo& videoEncodedFrameInfo) override;
+};
+```
+
+### YUV video receive callback
+
+```cpp
+class YuvFrameObserver : public agora::rtc::IVideoFrameObserver2 {
+public:
+    void onFrame(
+        const char* channelId,
+        agora::user_id_t remoteUid,
+        const agora::media::base::VideoFrame* frame) override;
+};
+```
+
+## Video Mixing
+
+```cpp
+// Create mixer and mixed video track
+agora::agora_refptr<agora::rtc::IVideoMixerSource> videoMixer =
+    factory->createVideoMixer();
+agora::agora_refptr<agora::rtc::ILocalVideoTrack> mixVideoTrack =
+    service->createMixedVideoTrack(videoMixer);
+
+// Configure encoder
+agora::rtc::VideoEncoderConfiguration encoderConfig;
+encoderConfig.codecType = agora::rtc::VIDEO_CODEC_H264;
+encoderConfig.dimensions.width = 1920;
+encoderConfig.dimensions.height = 1080;
+encoderConfig.frameRate = 15;
+mixVideoTrack->setVideoEncoderConfiguration(encoderConfig);
+
+// Add remote video tracks and set layout
+videoMixer->addVideoTrack(userId, remote_video_track_);
+videoMixer->setStreamLayout(userId, layout);  // position/size per user
+videoMixer->setBackground(1920, 1080, 15);
+videoMixer->refresh();  // apply layout changes
+```
+
+## Shutdown Sequence
+
+Order matters — follow exactly:
+
+```cpp
+// 1. Unpublish tracks
+connection->getLocalUser()->unpublishAudio(customAudioTrack);
+connection->getLocalUser()->unpublishVideo(customVideoTrack);
+
+// 2. Unregister observers
+connection->unregisterObserver(connObserver.get());
+local_user_->unregisterAudioFrameObserver(audio_frame_observer_);
+local_user_->unregisterVideoFrameObserver(video_frame_observer_);
+
+// 3. Disconnect
+connection->disconnect();
+
+// 4. Release objects (nullptr in this order)
+connObserver.reset();
+localUserObserver.reset();
+audioPcmDataSender = nullptr;
+videoFrameSender = nullptr;
+customAudioTrack = nullptr;
+customVideoTrack = nullptr;
+factory = nullptr;
+connection = nullptr;
+
+// 5. Release service last
+service->release();
+service = nullptr;
+```
+
+## Official Documentation
+
+- **[Send and Receive Media Streams](https://docs.agora.io/en/server-gateway/develop/send-receive-media-streams?platform=linux-cpp)**
+- **[Video Mixing](https://docs.agora.io/en/server-gateway/develop/video-mixing?platform=linux-cpp)**
+- **[API Reference](https://api-ref.agora.io/en/server-gateway-sdk/linux-cpp/4.x/index.html)**

package/assets/agora/references/testing-guidance/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: agora-testing-guidance
+description: |
+  Mocking patterns and testing requirements for Agora SDK integration code.
+  Covers RTC Web, RTC React, RTC iOS, RTC Android, RTC React Native, RTC Flutter,
+  RTM Web, RTM iOS, RTM Android, and ConvoAI REST API.
+  Use when generating tests for any Agora integration, or when reminding the user
+  to add tests to an implementation.
+license: MIT
+metadata:
+  author: agora
+  version: '1.0.0'
+---
+
+# Agora Testing Guidance
+
+Mocking patterns and completeness requirements for Agora SDK integration code.
+
+## When to Generate Tests
+
+Every code generation task that produces implementation code must include test stubs.
+If the user asks to "implement" something, remind them to generate tests before the
+task is complete. Do not mark an implementation task as done until tests are addressed.
+
+For the reminder template, see [completeness-gate.md](completeness-gate.md).
+
+## Route by Stack
+
+Use the file that matches the user's integration:
+
+| Stack | File |
+|---|---|
+| RTC Web (`agora-rtc-sdk-ng`) | [rtc-web.md](rtc-web.md) |
+| RTC React (`agora-rtc-react`) | [rtc-react.md](rtc-react.md) |
+| RTC iOS (Swift) | [rtc-ios.md](rtc-ios.md) |
+| RTC Android (Kotlin/Java) | [rtc-android.md](rtc-android.md) |
+| RTC React Native / Flutter / RTM Web / RTM iOS / RTM Android / token renewal | [mobile-rtm-and-renewal.md](mobile-rtm-and-renewal.md) |
+| ConvoAI REST API / backend HTTP integrations | [convoai-rest.md](convoai-rest.md) |
+| Completeness reminder and behavior-specific test prompts | [completeness-gate.md](completeness-gate.md) |
+
+## Core Rule
+
+Mock at the boundary your code owns:
+
+- SDK wrapper code: mock the SDK module or engine/client abstraction
+- UI hooks/components: mock the hooks or provider layer
+- REST integrations: mock the HTTP client, not the SDK
+- Native singletons/factories: wrap behind protocols/interfaces first, then inject mocks
+
+## Platform Notes
+
+- Prefer unit tests for join/publish/subscribe/token-renewal behavior.
+- For UI tests, assert rendered state after simulated SDK callbacks rather than trying to render the actual native/media views.
+- For ConvoAI, assert both request shape and auth headers.
+
+## Required Behaviors to Cover
+
+At minimum, generated tests should verify the behaviors most likely to break:
+
+- join/login is called with the correct channel and identity
+- tokens are renewed before expiry
+- cleanup happens in the right order
+- ConvoAI payload types are correct (`agent_rtc_uid` string, `remote_rtc_uids` array)
+- auth headers are present and sourced correctly
+- failure paths do not continue with partial initialization

package/assets/agora/references/testing-guidance/completeness-gate.md

@@ -0,0 +1,28 @@
+# Testing Guidance — Completeness Gate
+
+When generating an implementation, append the following reminder after the code block:
+
+```text
+> **Testing:** The above implementation is not complete without tests.
+> Generate unit tests that verify: [list specific behaviors from the implementation].
+> See `references/testing-guidance/SKILL.md` for mocking patterns.
+```
+
+Substitute `[list specific behaviors]` with the concrete behaviors the tests should
+cover. Do not leave the completeness gate as a generic reminder.
+
+Examples:
+
+- "join is called with the correct channel name and UID"
+- "agent_rtc_uid is passed as string, not integer"
+- "remote_rtc_uids is an array of strings"
+- "acquire is called before start; start is not called if acquire fails"
+- "RTM login resolves before subscribe is attempted"
+- "token renewal fetches a fresh token before expiry"
+
+## Rule
+
+Do not mark an implementation task as done until tests are either:
+
+- generated, or
+- explicitly called out as still required with concrete behaviors to cover

package/assets/agora/references/testing-guidance/convoai-rest.md

@@ -0,0 +1,83 @@
+# Testing Guidance — ConvoAI REST API
+
+Mock at the HTTP client layer. ConvoAI integration generates REST calls — mock the
+HTTP client, not the Agora SDK.
+
+## Python
+
+Use `unittest.mock.patch`:
+
+```python
+from unittest.mock import patch, MagicMock
+
+@patch('requests.post')
+def test_create_agent(mock_post):
+    mock_post.return_value = MagicMock(
+        status_code=200,
+        json=lambda: {"agent_id": "agent_abc123", "status": "STARTING"}
+    )
+
+    from your_module import create_agent
+    result = create_agent(channel="test-channel", uid="42")
+
+    assert result["agent_id"] == "agent_abc123"
+    mock_post.assert_called_once()
+    call_kwargs = mock_post.call_args
+    assert "Authorization" in call_kwargs.kwargs.get("headers", {})
+```
+
+## JavaScript / TypeScript
+
+Use `jest.spyOn` on `global.fetch`:
+
+```javascript
+beforeEach(() => {
+  jest.spyOn(global, 'fetch').mockResolvedValue({
+    ok: true,
+    json: async () => ({ agent_id: 'agent_abc123', status: 'STARTING' }),
+  })
+})
+
+afterEach(() => jest.restoreAllMocks())
+
+test('createAgent sends correct request', async () => {
+  await createAgent({ channel: 'test-channel', uid: '42' })
+  expect(fetch).toHaveBeenCalledWith(
+    expect.stringContaining('/join'),
+    expect.objectContaining({ method: 'POST' }),
+  )
+})
+```
+
+If using `axios`, use `axios-mock-adapter` or `jest.spyOn(axios, 'post')`.
+
+## Required Assertions
+
+Every ConvoAI REST integration test should verify:
+
+- `Authorization` header is present
+- the request body uses `agent_rtc_uid` as a string, not an integer
+- `remote_rtc_uids` is an array of strings
+- `name` is unique or generated dynamically
+- auth credentials/tokens come from environment or server config, not hardcoded literals
+- `/update` sends the full `params` object rather than only the changed field
+
+Example payload assertions:
+
+```javascript
+expect(fetch).toHaveBeenCalledWith(
+  expect.any(String),
+  expect.objectContaining({
+    headers: expect.objectContaining({
+      Authorization: expect.stringContaining('agora token='),
+    }),
+    body: expect.stringContaining('"agent_rtc_uid":"0"'),
+  }),
+)
+```
+
+Failure-path tests to include:
+
+- non-200 response surfaces `detail` / `reason`
+- 409 agent-name collision retries with a new name
+- request failure does not continue with partial local state

package/assets/agora/references/testing-guidance/mobile-rtm-and-renewal.md

@@ -0,0 +1,109 @@
+# Testing Guidance — React Native, Flutter, RTM, and Token Renewal
+
+## RTC React Native (`react-native-agora`)
+
+Mock at the module boundary using `jest.mock`. The engine is created via `createAgoraRtcEngine()` — mock the factory and capture the registered event handler so tests can fire callbacks.
+
+```javascript
+// __mocks__/react-native-agora.js
+const mockEngine = {
+  initialize: jest.fn().mockResolvedValue(undefined),
+  enableVideo: jest.fn().mockResolvedValue(undefined),
+  startPreview: jest.fn().mockResolvedValue(undefined),
+  joinChannel: jest.fn().mockResolvedValue(undefined),
+  leaveChannel: jest.fn().mockResolvedValue(undefined),
+  registerEventHandler: jest.fn(),
+  unregisterEventHandler: jest.fn(),
+  release: jest.fn().mockResolvedValue(undefined),
+}
+
+module.exports = {
+  createAgoraRtcEngine: jest.fn().mockReturnValue(mockEngine),
+  ChannelProfileType: { ChannelProfileCommunication: 1 },
+  ClientRoleType: { ClientRoleBroadcaster: 1, ClientRoleAudience: 2 },
+  RtcSurfaceView: 'RtcSurfaceView',
+}
+```
+
+Simulate callbacks by capturing the registered handler and calling methods directly.
+
+## RTC Flutter (`agora_rtc_engine`)
+
+Use the `mockito` package with `build_runner` to generate mocks. Inject the engine via constructor rather than calling `createAgoraRtcEngine()` directly.
+
+```yaml
+dev_dependencies:
+  mockito: ^5.4.0
+  build_runner: ^2.4.0
+```
+
+```dart
+@GenerateMocks([RtcEngine])
+void main() {}
+```
+
+Test join and leave behavior by stubbing async engine methods and verifying the correct parameters.
+
+## RTM Web (`agora-rtm`)
+
+Mock at the module boundary. The `RTM` constructor can throw — the mock should reflect that. Capture `addEventListener` calls so tests can simulate incoming events.
+
+```javascript
+const mockRtmClient = {
+  login: jest.fn().mockResolvedValue({}),
+  logout: jest.fn().mockResolvedValue({}),
+  subscribe: jest.fn().mockResolvedValue({}),
+  unsubscribe: jest.fn().mockResolvedValue({}),
+  publish: jest.fn().mockResolvedValue({}),
+  addEventListener: jest.fn(),
+}
+```
+
+Primary assertions:
+
+- `login` resolves before `subscribe`
+- incoming `message` events update UI/state
+- presence handling only works when subscribed with `withPresence: true`
+
+## RTM iOS / Android
+
+Use the same native pattern as RTC:
+
+- iOS: protocol-based injection around the RTM client
+- Android: interface extraction with Mockito
+
+Capture async completion callbacks so tests can simulate success/failure for login,
+subscribe, unsubscribe, and publish.
+
+Primary assertions:
+
+- login happens before subscribe
+- publish sends to the correct channel/topic
+- message callbacks update state correctly
+
+## Token Renewal Across Platforms
+
+Token renewal is a required production behavior. Cover both RTC and RTM paths:
+
+- RTC Web: `token-privilege-will-expire`
+- RTC iOS: `onTokenPrivilegeWillExpire`
+- RTC Android: `onTokenPrivilegeWillExpire`
+- RTM Web / native: token-expiry or status callbacks for RTM re-login
+
+Web example:
+
+```javascript
+test('handles RTM token expiry', async () => {
+  global.fetch = jest.fn().mockResolvedValue({
+    ok: true,
+    json: async () => ({ rtmToken: 'new-rtm-token' }),
+  })
+
+  const statusHandler = rtmClient.addEventListener.mock.calls
+    .find(([e]) => e === 'status')[1]
+
+  await statusHandler({ state: 'TOKEN_EXPIRED', reason: 'token expired' })
+
+  expect(rtmClient.login).toHaveBeenCalledWith({ token: 'new-rtm-token' })
+})
+```

package/assets/agora/references/testing-guidance/rtc-android.md

@@ -0,0 +1,70 @@
+# Testing Guidance — RTC Android (Kotlin)
+
+Use interface extraction with Mockito. `RtcEngine.create(context, appId, handler)`
+is a factory method — wrap it behind an interface to enable mocking.
+
+Pattern:
+
+```kotlin
+interface RtcEngineInterface {
+    fun joinChannel(token: String?, channelName: String, uid: Int,
+                    options: ChannelMediaOptions): Int
+    fun leaveChannel(): Int
+    fun enableVideo(): Int
+    fun muteLocalAudioStream(mute: Boolean): Int
+    fun renewToken(token: String): Int
+}
+
+class RtcEngineAdapter(private val engine: RtcEngine) : RtcEngineInterface {
+    override fun joinChannel(token: String?, channelName: String, uid: Int,
+                              options: ChannelMediaOptions) =
+        engine.joinChannel(token, channelName, uid, options)
+    override fun leaveChannel() = engine.leaveChannel()
+    override fun enableVideo() = engine.enableVideo()
+    override fun muteLocalAudioStream(mute: Boolean) = engine.muteLocalAudioStream(mute)
+    override fun renewToken(token: String) = engine.renewToken(token)
+}
+```
+
+Example:
+
+```kotlin
+@RunWith(MockitoJUnitRunner::class)
+class RtcManagerTest {
+    @Mock lateinit var mockEngine: RtcEngineInterface
+
+    @Test
+    fun `joins channel with correct parameters`() {
+        whenever(mockEngine.joinChannel(anyOrNull(), any(), any(), any())).thenReturn(0)
+
+        val manager = RtcManager(engine = mockEngine)
+        manager.join(channel = "test", token = null, uid = 0)
+
+        verify(mockEngine).joinChannel(eq(null), eq("test"), eq(0), any())
+    }
+
+    @Test
+    fun `renews token when privilege will expire`() {
+        val manager = RtcManager(engine = mockEngine)
+        val handler = manager.getRtcEventHandler()
+
+        handler.onTokenPrivilegeWillExpire("expiring-token")
+
+        verify(mockEngine, timeout(500)).renewToken(any())
+    }
+}
+```
+
+Add to `build.gradle`:
+
+```groovy
+testImplementation 'org.mockito:mockito-kotlin:5.+'
+testImplementation 'org.mockito:mockito-core:5.+'
+```
+
+Primary assertions:
+
+- join called with correct token/channel/UID
+- engine setup methods invoked in order
+- token renewal path is wired
+- cleanup/leave path runs on disconnect

package/assets/agora/references/testing-guidance/rtc-ios.md

@@ -0,0 +1,73 @@
+# Testing Guidance — RTC iOS (Swift)
+
+Use protocol-based injection. `AgoraRtcEngineKit.sharedEngine(withAppId:delegate:)`
+is a singleton — wrap it behind a protocol to enable mocking.
+
+Pattern:
+
+```swift
+protocol RtcEngineProtocol: AnyObject {
+    func joinChannel(byToken token: String?,
+                     channelId: String,
+                     uid: UInt,
+                     mediaOptions: AgoraRtcChannelMediaOptions) -> Int32
+    func leaveChannel(_ leaveChannelBlock: ((AgoraChannelStats) -> Void)?) -> Int32
+    func enableVideo() -> Int32
+    func muteLocalAudioStream(_ mute: Bool) -> Int32
+    func renewToken(_ token: String) -> Int32
+}
+
+extension AgoraRtcEngineKit: RtcEngineProtocol {}
+
+class RtcManager {
+    private let engine: RtcEngineProtocol
+    init(engine: RtcEngineProtocol = AgoraRtcEngineKit.sharedEngine(
+        withAppId: Config.appId, delegate: nil)) {
+        self.engine = engine
+    }
+}
+```
+
+Mock:
+
+```swift
+class MockRtcEngine: RtcEngineProtocol {
+    var joinChannelCallCount = 0
+    var renewedToken: String?
+
+    func joinChannel(byToken token: String?, channelId: String,
+                     uid: UInt,
+                     mediaOptions: AgoraRtcChannelMediaOptions) -> Int32 {
+        joinChannelCallCount += 1
+        return 0
+    }
+
+    func leaveChannel(_ leaveChannelBlock: ((AgoraChannelStats) -> Void)?) -> Int32 { 0 }
+    func enableVideo() -> Int32 { 0 }
+    func muteLocalAudioStream(_ mute: Bool) -> Int32 { 0 }
+    func renewToken(_ token: String) -> Int32 {
+        renewedToken = token
+        return 0
+    }
+}
+```
+
+Token renewal:
+
+```swift
+func testRenewsTokenBeforeExpiry() {
+    let mockEngine = MockRtcEngine()
+    let manager = RtcManager(engine: mockEngine)
+
+    manager.rtcEngine(mockEngine as! AgoraRtcEngineKit, tokenPrivilegeWillExpire: "expiring-token")
+
+    XCTAssertNotNil(mockEngine.renewedToken)
+}
+```
+
+Primary assertions:
+
+- join called with correct channel/token/UID
+- video/audio setup methods are invoked
+- token renewal path runs before expiry
+- leave/cleanup happens once