@stream-io/video-client 1.54.1-beta.0 → 1.55.1

package/src/rtc/IceTrickleBuffer.ts

@@ -1,33 +1,126 @@
-import { ReplaySubject } from 'rxjs';
+import { Observable, Subject } from 'rxjs';
 import { ICETrickle } from '../gen/video/sfu/event/events';
 import { PeerType } from '../gen/video/sfu/models/models';
 import { videoLoggerSystem } from '../logger';
+import { getCandidateUfrag, parseIceUfrag } from './helpers/iceCandiates';
+import { ensureExhausted } from '../helpers/ensureExhausted';
 
 /**
  * A buffer for ICE Candidates. Used for ICE Trickle:
  * - https://bloggeek.me/webrtcglossary/trickle-ice/
+ *
+ * The buffer is generation-aware: each peer connection tells it which ICE
+ * generation is current via `updateActiveGeneration` (whenever it applies an
+ * offer/answer). Candidate streams then emit only candidates of the active
+ * generation, hold candidates of a not-yet-applied (future) generation until
+ * it becomes active, and drop candidates of a superseded generation so they
+ * are never replayed. Candidates with no detectable generation, or before any
+ * generation is set, are emitted as-is (fail open).
  */
 export class IceTrickleBuffer {
-  readonly subscriberCandidates = new ReplaySubject<RTCIceCandidateInit>();
-  readonly publisherCandidates = new ReplaySubject<RTCIceCandidateInit>();
+  readonly subscriber = new CandidateGenerationBuffer();
+  readonly publisher = new CandidateGenerationBuffer();
 
   push = (iceTrickle: ICETrickle) => {
     const iceCandidate = toIceCandidate(iceTrickle);
     if (!iceCandidate) return;
 
-    if (iceTrickle.peerType === PeerType.SUBSCRIBER) {
-      this.subscriberCandidates.next(iceCandidate);
-    } else if (iceTrickle.peerType === PeerType.PUBLISHER_UNSPECIFIED) {
-      this.publisherCandidates.next(iceCandidate);
-    } else {
-      const logger = videoLoggerSystem.getLogger('sfu-client');
-      logger.warn(`ICETrickle, Unknown peer type`, iceTrickle);
+    const { peerType } = iceTrickle;
+    switch (peerType) {
+      case PeerType.SUBSCRIBER:
+        this.subscriber.push(iceCandidate);
+        break;
+      case PeerType.PUBLISHER_UNSPECIFIED:
+        this.publisher.push(iceCandidate);
+        break;
+      default:
+        ensureExhausted(peerType, `ICETrickle, Unknown peer type`);
+    }
+  };
+
+  /**
+   * Declares the ICE generation that is now current for the given peer type,
+   * derived from the `ice-ufrag` of the just-applied remote description.
+   * Candidates of superseded generations are evicted; candidates of the active
+   * generation flow to subscribers.
+   */
+  updateActiveGeneration = (peerType: PeerType, sdp: string | undefined) => {
+    const ufrag = parseIceUfrag(sdp);
+    switch (peerType) {
+      case PeerType.SUBSCRIBER:
+        this.subscriber.updateActiveGeneration(ufrag);
+        break;
+      case PeerType.PUBLISHER_UNSPECIFIED:
+        this.publisher.updateActiveGeneration(ufrag);
+        break;
+      default:
+        ensureExhausted(peerType, `updateActiveGeneration, Unknown peer type`);
     }
   };
 
   dispose = () => {
-    this.subscriberCandidates.complete();
-    this.publisherCandidates.complete();
+    this.subscriber.dispose();
+    this.publisher.dispose();
+  };
+}
+
+/**
+ * Per-peer-connection generation-aware candidate store. Retains trickled
+ * candidates and replays the active generation to each new subscriber, then
+ * forwards matching live candidates.
+ */
+class CandidateGenerationBuffer {
+  private readonly store: RTCIceCandidateInit[] = [];
+  private readonly live = new Subject<RTCIceCandidateInit>();
+  private readonly seenUfrags = new Set<string>();
+  private activeUfrag: string | undefined;
+
+  readonly candidates = new Observable<RTCIceCandidateInit>((subscriber) => {
+    for (const candidate of this.store.slice()) {
+      if (this.isCurrent(candidate)) subscriber.next(candidate);
+    }
+    const subscription = this.live.subscribe((candidate) => {
+      if (this.isCurrent(candidate)) subscriber.next(candidate);
+    });
+    return () => subscription.unsubscribe();
+  });
+
+  push = (candidate: RTCIceCandidateInit) => {
+    this.store.push(candidate);
+    this.live.next(candidate);
+  };
+
+  updateActiveGeneration = (ufrag: string | undefined) => {
+    if (ufrag) this.seenUfrags.add(ufrag);
+    this.activeUfrag = ufrag;
+    // evict candidates from superseded generations (a generation we have
+    // applied before but is no longer current); keep future generations.
+    for (let i = this.store.length - 1; i >= 0; i--) {
+      const candidateUfrag = getCandidateUfrag(this.store[i]);
+      if (
+        candidateUfrag &&
+        candidateUfrag !== this.activeUfrag &&
+        this.seenUfrags.has(candidateUfrag)
+      ) {
+        this.store.splice(i, 1);
+      }
+    }
+  };
+
+  dispose = () => {
+    this.store.length = 0;
+    this.live.complete();
+  };
+
+  /**
+   * A candidate belongs to the current generation when its ufrag matches the
+   * active one. Fail open when either the candidate's generation or the active
+   * generation is unknown, so untagged candidates are never withheld.
+   */
+  private isCurrent = (candidate: RTCIceCandidateInit): boolean => {
+    const candidateUfrag = getCandidateUfrag(candidate);
+    if (!candidateUfrag || !this.activeUfrag) return true;
+    return candidateUfrag === this.activeUfrag;
   };
 }
 

package/src/rtc/Publisher.ts

@@ -1,34 +1,34 @@
-import { BasePeerConnection } from './BasePeerConnection';
-import type {
-  BasePeerConnectionOpts,
-  PublishBundle,
-  TrackPublishOptions,
-} from './types';
-import { NegotiationError } from './NegotiationError';
-import { TransceiverCache } from './TransceiverCache';
+import { VideoSender } from '../gen/video/sfu/event/events';
 import {
   PeerType,
   PublishOption,
   TrackInfo,
   TrackType,
 } from '../gen/video/sfu/models/models';
-import { VideoSender } from '../gen/video/sfu/event/events';
-import {
-  computeAudioLayers,
-  computeVideoLayers,
-  toSvcEncodings,
-  toVideoLayers,
-} from './layers';
+import { isFirefox } from '../helpers/browsers';
+import { withoutConcurrency } from '../helpers/concurrency';
+import { isReactNative } from '../helpers/platforms';
+import { BasePeerConnection } from './BasePeerConnection';
 import { isSvcCodec } from './codecs';
 import {
   fromRTCDegradationPreference,
   toRTCDegradationPreference,
 } from './helpers/degradationPreference';
-import { isAudioTrackType } from './helpers/tracks';
 import { extractMid, removeCodecsExcept, setStartBitrate } from './helpers/sdp';
-import { withoutConcurrency } from '../helpers/concurrency';
-import { isReactNative } from '../helpers/platforms';
-import { isFirefox } from '../helpers/browsers';
+import { isAudioTrackType } from './helpers/tracks';
+import {
+  computeAudioLayers,
+  computeVideoLayers,
+  toSvcEncodings,
+  toVideoLayers,
+} from './layers';
+import { NegotiationError } from './NegotiationError';
+import { TransceiverCache } from './TransceiverCache';
+import type {
+  BasePeerConnectionOpts,
+  PublishBundle,
+  TrackPublishOptions,
+} from './types';
 
 /**
  * The `Publisher` is responsible for publishing/unpublishing media streams to/from the SFU
@@ -187,6 +187,9 @@ export class Publisher extends BasePeerConnection {
     if (isAudioTrackType(trackType)) {
       await this.updateAudioPublishOptions(trackType, options);
     }
+    if (track && !bundle.negotiated) {
+      await this.negotiate();
+    }
   };
 
   /**
@@ -490,6 +493,10 @@ export class Publisher extends BasePeerConnection {
 
         const { sdp: answerSdp } = response;
         await this.pc.setRemoteDescription({ type: 'answer', sdp: answerSdp });
+
+        for (const bundle of this.transceiverCache.items()) {
+          if (bundle.transceiver.sender.track) bundle.negotiated = true;
+        }
       } catch (err) {
         // negotiation failed, rollback to the previous state
         if (this.pc.signalingState === 'have-local-offer') {

package/src/rtc/Subscriber.ts

@@ -1,7 +1,11 @@
 import { BasePeerConnection } from './BasePeerConnection';
-import { BasePeerConnectionOpts } from './types';
+import { BasePeerConnectionOpts, ReconnectReason } from './types';
 import { NegotiationError } from './NegotiationError';
-import { PeerType, TrackType } from '../gen/video/sfu/models/models';
+import {
+  PeerType,
+  TrackType,
+  WebsocketReconnectStrategy,
+} from '../gen/video/sfu/models/models';
 import { SubscriberOffer } from '../gen/video/sfu/event/events';
 import { toTrackType, trackTypeToParticipantStreamKey } from './helpers/tracks';
 import { pushToIfMissing, removeFromIfPresent } from '../helpers/array';
@@ -20,7 +24,8 @@ export class Subscriber extends BasePeerConnection {
    * The map will never contain local streams so we can safely use it to
    * check if the stream is remote and dispose it when needed.
    */
-  private trackedStreams: WeakSet<MediaStream> = new WeakSet();
+  private trackedStreams?: WeakSet<MediaStream>;
+  private negotiationFailures = 0;
 
   /**
    * Constructs a new `Subscriber` instance.
@@ -30,9 +35,25 @@ export class Subscriber extends BasePeerConnection {
     this.pc.addEventListener('track', this.handleOnTrack);
 
     this.on('subscriberOffer', async (subscriberOffer) => {
-      return this.negotiate(subscriberOffer).catch((err) => {
-        this.logger.error(`Negotiation failed.`, err);
-      });
+      try {
+        const result = await this.negotiate(subscriberOffer);
+        this.negotiationFailures = 0;
+        return result;
+      } catch (err: any) {
+        const message = 'subscriber.negotiationFailed';
+        this.tracer?.trace(message, err.message);
+        this.logger.warn(message, err);
+
+        const failures = ++this.negotiationFailures;
+        if (failures < 3) return this.tryRestartIce();
+
+        this.logger.error(`negotiation failed ${failures} times, rejoining`);
+        this.onReconnectionNeeded?.(
+          WebsocketReconnectStrategy.REJOIN,
+          ReconnectReason.SUBSCRIBER_NEGOTIATION_FAILED,
+          this.peerType,
+        );
+      }
     });
   }
 
@@ -52,13 +73,11 @@ export class Subscriber extends BasePeerConnection {
   restartIce = async () => {
     this.logger.debug('Restarting ICE connection');
     if (this.pc.signalingState === 'have-remote-offer') {
-      this.logger.debug('ICE restart is already in progress');
+      this.logger.debug('ICE negotiation is already in progress');
       return;
     }
     if (this.pc.connectionState === 'new') {
-      this.logger.debug(
-        `ICE connection is not yet established, skipping restart.`,
-      );
+      this.logger.debug(`ICE connection not yet established, skipping restart`);
       return;
     }
     const previousIsIceRestarting = this.isIceRestarting;
@@ -118,6 +137,7 @@ export class Subscriber extends BasePeerConnection {
     this.trackIdToTrackType.set(track.id, trackType);
 
     if (isSelfSub) {
+      this.trackedStreams ??= new WeakSet<MediaStream>();
       this.trackedStreams.add(primaryStream);
     }
 
@@ -159,7 +179,7 @@ export class Subscriber extends BasePeerConnection {
     });
 
     if (previousStream) {
-      if (isSelfSub && !this.trackedStreams.has(previousStream)) {
+      if (isSelfSub && !this.trackedStreams?.has(previousStream)) {
         // this is the local capture stream, we don't want to dispose it
         this.logger.debug(
           `[onTrack]: Skipping cleanup of previous ${e.track.kind} stream for userId: ${participantToUpdate.userId} because it is not tracked`,
@@ -199,34 +219,48 @@ export class Subscriber extends BasePeerConnection {
   };
 
   private negotiate = async (subscriberOffer: SubscriberOffer) => {
-    await this.pc.setRemoteDescription({
-      type: 'offer',
-      sdp: subscriberOffer.sdp,
-    });
+    // The generation currently committed on the peer connection. If this
+    // negotiation fails and rolls back, the buffer is restored to it.
+    const previousSdp = this.pc.currentRemoteDescription?.sdp;
+    try {
+      await this.pc.setRemoteDescription({
+        type: 'offer',
+        sdp: subscriberOffer.sdp,
+      });
 
-    this.addTrickledIceCandidates();
-
-    const answer = await this.pc.createAnswer();
-    if (answer.sdp) {
-      answer.sdp = enableStereo(subscriberOffer.sdp, answer.sdp);
-      const { dangerouslyForceCodec, subscriberFmtpLine } =
-        this.clientPublishOptions || {};
-      if (dangerouslyForceCodec) {
-        answer.sdp = removeCodecsExcept(
-          answer.sdp,
-          dangerouslyForceCodec,
-          subscriberFmtpLine,
-        );
-      }
-    }
-    await this.pc.setLocalDescription(answer);
+      this.addTrickledIceCandidates();
 
-    await this.sfuClient.sendAnswer({
-      peerType: PeerType.SUBSCRIBER,
-      sdp: answer.sdp || '',
-      negotiationId: subscriberOffer.negotiationId,
-    });
+      const answer = await this.pc.createAnswer();
+      if (answer.sdp) {
+        answer.sdp = enableStereo(subscriberOffer.sdp, answer.sdp);
+        const { dangerouslyForceCodec, subscriberFmtpLine } =
+          this.clientPublishOptions || {};
+        if (dangerouslyForceCodec) {
+          answer.sdp = removeCodecsExcept(
+            answer.sdp,
+            dangerouslyForceCodec,
+            subscriberFmtpLine,
+          );
+        }
+      }
+      await this.pc.setLocalDescription(answer);
 
-    this.isIceRestarting = false;
+      await this.sfuClient.sendAnswer({
+        peerType: PeerType.SUBSCRIBER,
+        sdp: answer.sdp || '',
+        negotiationId: subscriberOffer.negotiationId,
+      });
+    } catch (err) {
+      if (this.pc.signalingState === 'have-remote-offer') {
+        await this.pc.setRemoteDescription({ type: 'rollback' }).catch((e) => {
+          this.logger.warn('Failed to rollback after negotiation error', e);
+        });
+        const { iceTrickleBuffer } = this.sfuClient;
+        iceTrickleBuffer.updateActiveGeneration(this.peerType, previousSdp);
+      }
+      throw err;
+    } finally {
+      this.isIceRestarting = false;
+    }
   };
 }

package/src/rtc/__tests__/Call.reconnect.test.ts

@@ -818,43 +818,6 @@ describe('Call reconnect wiring (PC event → leave)', () => {
     expect(publisher.restartIce).toHaveBeenCalled();
   });
 
-  /**
-   * Scenario 4 (manual smoke equivalent: drop only the signal WS while the
-   * publisher PC stays `connected`): the FAST path should NOT call
-   * `publisher.restartIce()` because the PC is stable.
-   */
-  it('FAST path skips publisher.restartIce when publisher PC is stable', async () => {
-    const publisher = makePublisherWiredToCall();
-    // @ts-expect-error private field
-    publisher['pc'].iceConnectionState = 'connected';
-    publisher['onIceConnectionStateChange']();
-    // @ts-expect-error private field
-    publisher['pc'].connectionState = 'connected';
-
-    // pretend the publisher has tracks so isPublishing() would return true
-    vi.spyOn(publisher, 'isPublishing').mockReturnValue(true);
-    const restartIceSpy = vi.spyOn(publisher, 'restartIce').mockResolvedValue();
-    const setSfuSpy = vi.spyOn(publisher, 'setSfuClient');
-    call['publisher'] = publisher;
-
-    // mimic the FAST branch in doJoin: restoreICE is the gateway
-    const publisherIsStable = call['publisher']?.isStable() ?? true;
-    const includePublisher =
-      !!call['publisher']?.isPublishing() && !publisherIsStable;
-    await call['restoreICE'](sfuClient, {
-      includeSubscriber: false,
-      includePublisher,
-    });
-
-    expect(includePublisher).toBe(false);
-    expect(setSfuSpy).toHaveBeenCalledWith(sfuClient); // wire still updated
-    expect(restartIceSpy).not.toHaveBeenCalled(); // but NO ICE restart
-  });
-
-  /**
-   * Counterpart to the above: when the publisher PC is NOT stable (e.g.,
-   * `disconnected`), the FAST path SHOULD still issue an ICE restart.
-   */
   it('FAST path DOES call publisher.restartIce when publisher PC is unstable', async () => {
     const publisher = makePublisherWiredToCall();
     // @ts-expect-error private field
@@ -869,15 +832,8 @@ describe('Call reconnect wiring (PC event → leave)', () => {
     const restartIceSpy = vi.spyOn(publisher, 'restartIce').mockResolvedValue();
     call['publisher'] = publisher;
 
-    const publisherIsStable = call['publisher']?.isStable() ?? true;
-    const includePublisher =
-      !!call['publisher']?.isPublishing() && !publisherIsStable;
-    await call['restoreICE'](sfuClient, {
-      includeSubscriber: false,
-      includePublisher,
-    });
+    await call['restoreICE'](sfuClient, { includeSubscriber: false });
 
-    expect(includePublisher).toBe(true);
     expect(restartIceSpy).toHaveBeenCalled();
   });
 
@@ -998,6 +954,50 @@ describe('Call reconnect wiring (PC event → leave)', () => {
   });
 });
 
+/**
+ * `handleSfuSignalClose` is the bridge from a dead signal WS to the reconnect
+ * loop. A reconnect swaps in a fresh SFU client, but the old socket can still
+ * fire a (delayed) `close` later. Such stragglers must be ignored: only the
+ * currently-active client may drive a reconnect.
+ */
+describe('Call.handleSfuSignalClose superseded-client guard', () => {
+  let call: Call;
+
+  beforeEach(() => {
+    call = makeCall();
+    vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('ignores a signal close from a superseded SFU client', () => {
+    call.state.setCallingState(CallingState.JOINED);
+    const reconnectSpy = vi
+      .spyOn(call as unknown as { reconnect: () => Promise<void> }, 'reconnect')
+      .mockResolvedValue(undefined);
+
+    const currentClient = { isLeaving: false, isClosingClean: false };
+    const supersededClient = { isLeaving: false, isClosingClean: false };
+    (call as unknown as { sfuClient: unknown }).sfuClient = currentClient;
+
+    // a close from a client that is no longer active must not reconnect
+    call['handleSfuSignalClose'](
+      supersededClient as unknown as StreamSfuClient,
+      '1006 ',
+    );
+    expect(reconnectSpy).not.toHaveBeenCalled();
+
+    // the active client's close still drives a reconnect
+    call['handleSfuSignalClose'](
+      currentClient as unknown as StreamSfuClient,
+      '1006 ',
+    );
+    expect(reconnectSpy).toHaveBeenCalledTimes(1);
+  });
+});
+
 /**
  * `leave()` runs after both the success path (end of `joinFlow`) and the
  * giveUpAndLeave path. Only the success path resets `reconnectStrategy` /

package/src/rtc/__tests__/IceTrickleBuffer.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest';
+import { IceTrickleBuffer } from '../IceTrickleBuffer';
+import { PeerType } from '../../gen/video/sfu/models/models';
+
+// The generation is carried via `usernameFragment` (the key getCandidateUfrag
+// reads); the candidate-string `ufrag` token path has its own helper tests.
+const trickle = (
+  ufrag: string | undefined,
+  candidate: string,
+  peerType = PeerType.SUBSCRIBER,
+) => ({
+  peerType,
+  iceCandidate: JSON.stringify(
+    ufrag ? { usernameFragment: ufrag, candidate } : { candidate },
+  ),
+});
+
+const sdp = (ufrag: string) =>
+  `v=0\r\na=ice-ufrag:${ufrag}\r\na=ice-pwd:pwd\r\n`;
+
+const collect = (
+  observable: IceTrickleBuffer['subscriber']['candidates'],
+): RTCIceCandidateInit[] => {
+  const seen: RTCIceCandidateInit[] = [];
+  observable.subscribe((c) => seen.push(c)).unsubscribe();
+  return seen;
+};
+
+describe('IceTrickleBuffer', () => {
+  it('emits buffered candidates of the active generation to a new subscriber', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.push(trickle('u1', 'a'));
+    buffer.push(trickle('u1', 'b'));
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { usernameFragment: 'u1', candidate: 'a' },
+      { usernameFragment: 'u1', candidate: 'b' },
+    ]);
+  });
+
+  it('emits live candidates of the active generation', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    const seen: RTCIceCandidateInit[] = [];
+    buffer.subscriber.candidates.subscribe((c) => seen.push(c));
+
+    buffer.push(trickle('u1', 'a'));
+
+    expect(seen).toEqual([{ usernameFragment: 'u1', candidate: 'a' }]);
+  });
+
+  it('drops superseded-generation candidates once the generation advances', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u0'));
+    buffer.push(trickle('u0', 'old'));
+
+    // ICE restart -> new generation
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    buffer.push(trickle('u1', 'new'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { usernameFragment: 'u1', candidate: 'new' },
+    ]);
+  });
+
+  it('holds future-generation candidates until their generation becomes active', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    // a candidate for a not-yet-applied generation arrives early (trickle race)
+    buffer.push(trickle('u2', 'future'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([]);
+
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u2'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { usernameFragment: 'u2', candidate: 'future' },
+    ]);
+  });
+
+  it('emits candidates without a generation marker (fail-open)', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    buffer.push(trickle(undefined, 'no-generation'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { candidate: 'no-generation' },
+    ]);
+  });
+
+  it('emits all candidates when no active generation is set (fail-open)', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.push(trickle('u1', 'a'));
+    buffer.push(trickle('u2', 'b'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { usernameFragment: 'u1', candidate: 'a' },
+      { usernameFragment: 'u2', candidate: 'b' },
+    ]);
+  });
+
+  it('keeps subscriber and publisher generations independent', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.push(trickle('u1', 'sub', PeerType.SUBSCRIBER));
+    buffer.push(trickle('p1', 'pub', PeerType.PUBLISHER_UNSPECIFIED));
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    buffer.updateActiveGeneration(PeerType.PUBLISHER_UNSPECIFIED, sdp('p1'));
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([
+      { usernameFragment: 'u1', candidate: 'sub' },
+    ]);
+    expect(collect(buffer.publisher.candidates)).toEqual([
+      { usernameFragment: 'p1', candidate: 'pub' },
+    ]);
+  });
+
+  it('dispose clears retained candidates', () => {
+    const buffer = new IceTrickleBuffer();
+    buffer.updateActiveGeneration(PeerType.SUBSCRIBER, sdp('u1'));
+    buffer.push(trickle('u1', 'a'));
+
+    buffer.dispose();
+
+    expect(collect(buffer.subscriber.candidates)).toEqual([]);
+  });
+});