mockrtc 0.3.2 → 0.5.0

package/src/handling/{handler-steps.ts → handler-step-impls.ts}

@@ -12,27 +12,27 @@ import type { MockRTCConnection } from '../webrtc/mockrtc-connection';
 import { RTCConnection } from '../webrtc/rtc-connection';
 import {
     StepDefinitionLookup,
-    CloseStepDefinition,
-    DynamicProxyStepDefinition,
-    EchoStepDefinition,
+    CloseStep,
+    DynamicProxyStep,
+    EchoStep,
     HandlerStepDefinition,
-    PeerProxyStepDefinition,
-    CreateChannelStepDefinition,
-    SendStepDefinition,
-    WaitForChannelStepDefinition,
-    WaitForDurationStepDefinition,
-    WaitForMediaStepDefinition,
-    WaitForMessageStepDefinition,
-    WaitForTrackStepDefinition
+    PeerProxyStep,
+    CreateChannelStep,
+    SendStep,
+    WaitForChannelStep,
+    WaitForDurationStep,
+    WaitForMediaStep,
+    WaitForMessageStep,
+    WaitForTrackStep
 } from './handler-step-definitions';
 
 type ClientServerChannel = PluggableAdmin.Serialization.ClientServerChannel;
 
-export interface HandlerStep extends HandlerStepDefinition {
+export interface HandlerStepImpl extends HandlerStepDefinition {
     handle(connection: MockRTCConnection): Promise<void>;
 }
 
-export class WaitForDurationStep extends WaitForDurationStepDefinition {
+export class WaitForDurationStepImpl extends WaitForDurationStep {
 
     async handle(): Promise<void> {
         return new Promise<void>((resolve) => setTimeout(resolve, this.durationMs));
@@ -40,7 +40,7 @@ export class WaitForDurationStep extends WaitForDurationStepDefinition {
 
 }
 
-export class WaitForChannelStep extends WaitForChannelStepDefinition {
+export class WaitForChannelStepImpl extends WaitForChannelStep {
 
     private matchesChannel(channel: DataChannelStream) {
         return this.channelLabel === undefined || this.channelLabel === channel.label;
@@ -62,7 +62,7 @@ export class WaitForChannelStep extends WaitForChannelStepDefinition {
 
 }
 
-export class WaitForMessageStep extends WaitForMessageStepDefinition {
+export class WaitForMessageStepImpl extends WaitForMessageStep {
 
     private matchesChannel(channel: DataChannelStream) {
         return this.channelLabel === undefined || this.channelLabel === channel.label;
@@ -93,7 +93,7 @@ export class WaitForMessageStep extends WaitForMessageStepDefinition {
 
 }
 
-export class WaitForTrackStep extends WaitForTrackStepDefinition {
+export class WaitForTrackStepImpl extends WaitForTrackStep {
 
     async handle(connection: MockRTCConnection): Promise<void> {
         await new Promise<void>((resolve) => {
@@ -104,7 +104,7 @@ export class WaitForTrackStep extends WaitForTrackStepDefinition {
 
 }
 
-export class WaitForMediaStep extends WaitForMediaStepDefinition {
+export class WaitForMediaStepImpl extends WaitForMediaStep {
 
     async handle(connection: MockRTCConnection): Promise<void> {
         return new Promise<void>((resolve) => {
@@ -129,7 +129,7 @@ export class WaitForMediaStep extends WaitForMediaStepDefinition {
 
 }
 
-export class CreateChannelStep extends CreateChannelStepDefinition {
+export class CreateChannelStepImpl extends CreateChannelStep {
 
     async handle(conn: MockRTCConnection): Promise<void> {
         const channel = conn.createDataChannel(this.channelLabel);
@@ -140,7 +140,7 @@ export class CreateChannelStep extends CreateChannelStepDefinition {
 
 }
 
-export class SendStep extends SendStepDefinition {
+export class SendStepImpl extends SendStep {
 
     private matchesChannel(channel: DataChannelStream) {
         return this.channelLabel === undefined || this.channelLabel === channel.label;
@@ -177,7 +177,7 @@ export class SendStep extends SendStepDefinition {
 
 }
 
-export class CloseStep extends CloseStepDefinition {
+export class CloseStepImpl extends CloseStep {
 
     async handle(connection: MockRTCConnection): Promise<void> {
         await connection.close();
@@ -185,7 +185,7 @@ export class CloseStep extends CloseStepDefinition {
 
 }
 
-export class EchoStep extends EchoStepDefinition {
+export class EchoStepImpl extends EchoStep {
 
     async handle(connection: MockRTCConnection): Promise<void> {
         const echoContent = (stream: DataChannelStream | MediaTrackStream) => {
@@ -203,9 +203,7 @@ export class EchoStep extends EchoStepDefinition {
 
 }
 
-export class PeerProxyStep extends PeerProxyStepDefinition {
-
-    private externalConnections: RTCConnection[] = [];
+export class PeerProxyStepImpl extends PeerProxyStep {
 
     async handle(connection: MockRTCConnection) {
         const externalConn = new RTCConnection();
@@ -250,12 +248,11 @@ export class PeerProxyStep extends PeerProxyStepDefinition {
 
 }
 
-export class DynamicProxyStep extends DynamicProxyStepDefinition {
-
-    private externalConnections: RTCConnection[] = [];
+export class DynamicProxyStepImpl extends DynamicProxyStep {
 
     async handle(connection: MockRTCConnection) {
-        await connection.proxyTrafficToExternalConnection();
+        const externalConn = await connection.proxyTrafficToExternalConnection();
+        this.externalConnections.push(externalConn);
 
         // This step keeps running indefinitely, until the connection closes
         return new Promise<void>((resolve) => connection.on('connection-closed', resolve));
@@ -268,15 +265,15 @@ export class DynamicProxyStep extends DynamicProxyStepDefinition {
 }
 
 export const StepLookup: typeof StepDefinitionLookup = {
-    'wait-for-duration': WaitForDurationStep,
-    'wait-for-rtc-data-channel': WaitForChannelStep,
-    'wait-for-rtc-track': WaitForTrackStep,
-    'wait-for-rtc-media': WaitForMediaStep,
-    'wait-for-rtc-message': WaitForMessageStep,
-    'create-rtc-data-channel': CreateChannelStep,
-    'send-rtc-data-message': SendStep,
-    'close-rtc-connection': CloseStep,
-    'echo-rtc': EchoStep,
-    'rtc-peer-proxy': PeerProxyStep,
-    'rtc-dynamic-proxy': DynamicProxyStep
+    'wait-for-duration': WaitForDurationStepImpl,
+    'wait-for-rtc-data-channel': WaitForChannelStepImpl,
+    'wait-for-rtc-track': WaitForTrackStepImpl,
+    'wait-for-rtc-media': WaitForMediaStepImpl,
+    'wait-for-rtc-message': WaitForMessageStepImpl,
+    'create-rtc-data-channel': CreateChannelStepImpl,
+    'send-rtc-data-message': SendStepImpl,
+    'close-rtc-connection': CloseStepImpl,
+    'echo-rtc': EchoStepImpl,
+    'rtc-peer-proxy': PeerProxyStepImpl,
+    'rtc-dynamic-proxy': DynamicProxyStepImpl
 };

package/src/main-browser.ts

@@ -10,8 +10,8 @@ import type {
 import { MockRTCClient, MockRTCClientOptions } from "./client/mockrtc-client";
 
 // Export the required structures to remotely build and send rules to the admin API:
-export * as HandlerStepDefinitions from "./handling/handler-step-definitions";
-export * as MatcherDefinitions from "./matching/matcher-definitions";
+export * as steps from "./handling/handler-step-definitions";
+export * as matchers from "./matching/matcher-definitions";
 export { MockRTCAdminRequestBuilder } from "./client/mockrtc-admin-request-builder";
 
 export type {

package/src/main.ts

@@ -22,12 +22,12 @@ export { MockRTCAdminPlugin } from "./server/mockrtc-admin-plugin";
 import { MockRTCClient, MockRTCClientOptions } from "./client/mockrtc-client";
 
 // Export the required structures to remotely build and send rules to the admin API:
-export * as HandlerStepDefinitions from "./handling/handler-step-definitions";
-export * as MatcherDefinitions from "./matching/matcher-definitions";
+export * as steps from "./handling/handler-step-definitions";
+export * as matchers from "./matching/matcher-definitions";
 export { MockRTCAdminRequestBuilder } from "./client/mockrtc-admin-request-builder";
 
 // Re-export lots of types are used in various APIs (mostly to make TypeDoc happy):
-export type { HandlerStep } from "./handling/handler-steps";
+export type { HandlerStepImpl as HandlerStep } from "./handling/handler-step-impls";
 export type { MockRTCHandlerBuilder } from "./handling/handler-builder";
 export type { MockRTCRuleBuilder, RuleHandlerBuilder } from "./rule-builder";
 

package/src/matching/matcher-definitions.ts

@@ -12,7 +12,7 @@ export interface MatcherDefinition extends Serializable {
     readonly type: keyof typeof MatcherDefinitionLookup;
 }
 
-export class HasDataChannelMatcherDefinition extends Serializable implements MatcherDefinition {
+export class HasDataChannelMatcher extends Serializable implements MatcherDefinition {
     readonly type = 'has-rtc-data-channel';
 
     explain() {
@@ -20,7 +20,7 @@ export class HasDataChannelMatcherDefinition extends Serializable implements Mat
     }
 }
 
-export class HasVideoTrackMatcherDefinition extends Serializable implements MatcherDefinition {
+export class HasVideoTrackMatcher extends Serializable implements MatcherDefinition {
     readonly type = 'has-rtc-video-track';
 
     explain() {
@@ -28,7 +28,7 @@ export class HasVideoTrackMatcherDefinition extends Serializable implements Matc
     }
 }
 
-export class HasAudioTrackMatcherDefinition extends Serializable implements MatcherDefinition {
+export class HasAudioTrackMatcher extends Serializable implements MatcherDefinition {
     readonly type = 'has-rtc-audio-track';
 
     explain() {
@@ -36,7 +36,7 @@ export class HasAudioTrackMatcherDefinition extends Serializable implements Matc
     }
 }
 
-export class HasMediaTrackMatcherDefinition extends Serializable implements MatcherDefinition {
+export class HasMediaTrackMatcher extends Serializable implements MatcherDefinition {
     readonly type = 'has-rtc-media-track';
 
     explain() {
@@ -44,7 +44,7 @@ export class HasMediaTrackMatcherDefinition extends Serializable implements Matc
     }
 }
 
-export class HostnameMatcherDefinition extends Serializable implements MatcherDefinition {
+export class HostnameMatcher extends Serializable implements MatcherDefinition {
 
     readonly type = 'rtc-page-hostname';
 
@@ -60,7 +60,7 @@ export class HostnameMatcherDefinition extends Serializable implements MatcherDe
 
 }
 
-export class UrlRegexMatcherDefinition extends Serializable implements MatcherDefinition {
+export class UrlRegexMatcher extends Serializable implements MatcherDefinition {
 
     readonly type = 'rtc-page-regex';
 
@@ -79,7 +79,7 @@ export class UrlRegexMatcherDefinition extends Serializable implements MatcherDe
 
 }
 
-export class UserAgentRegexMatcherDefinition  extends Serializable implements MatcherDefinition {
+export class UserAgentRegexMatcher  extends Serializable implements MatcherDefinition {
 
     readonly type = 'rtc-user-agent-regex';
 
@@ -99,11 +99,11 @@ export class UserAgentRegexMatcherDefinition  extends Serializable implements Ma
 }
 
 export const MatcherDefinitionLookup = {
-    'has-rtc-data-channel': HasDataChannelMatcherDefinition,
-    'has-rtc-video-track': HasVideoTrackMatcherDefinition,
-    'has-rtc-audio-track': HasAudioTrackMatcherDefinition,
-    'has-rtc-media-track': HasMediaTrackMatcherDefinition,
-    'rtc-page-hostname': HostnameMatcherDefinition,
-    'rtc-page-regex': UrlRegexMatcherDefinition,
-    'rtc-user-agent-regex': UserAgentRegexMatcherDefinition
+    'has-rtc-data-channel': HasDataChannelMatcher,
+    'has-rtc-video-track': HasVideoTrackMatcher,
+    'has-rtc-audio-track': HasAudioTrackMatcher,
+    'has-rtc-media-track': HasMediaTrackMatcher,
+    'rtc-page-hostname': HostnameMatcher,
+    'rtc-page-regex': UrlRegexMatcher,
+    'rtc-user-agent-regex': UserAgentRegexMatcher
 };

package/src/matching/{matchers.ts → matcher-impls.ts}

@@ -7,20 +7,20 @@ import { RTCConnection } from "../webrtc/rtc-connection";
 import {
     MatcherDefinition,
     MatcherDefinitionLookup,
-    HasAudioTrackMatcherDefinition,
-    HasDataChannelMatcherDefinition,
-    HasMediaTrackMatcherDefinition,
-    HasVideoTrackMatcherDefinition,
-    HostnameMatcherDefinition,
-    UrlRegexMatcherDefinition,
-    UserAgentRegexMatcherDefinition
+    HasAudioTrackMatcher,
+    HasDataChannelMatcher,
+    HasMediaTrackMatcher,
+    HasVideoTrackMatcher,
+    HostnameMatcher,
+    UrlRegexMatcher,
+    UserAgentRegexMatcher
 } from "./matcher-definitions";
 
-export interface Matcher extends MatcherDefinition {
+export interface MatcherImpl extends MatcherDefinition {
     matches(connection: RTCConnection): boolean;
 }
 
-export class HasDataChannelMatcher extends HasDataChannelMatcherDefinition {
+export class HasDataChannelMatcherImpl extends HasDataChannelMatcher {
 
     matches(connection: RTCConnection): boolean {
         return [
@@ -31,7 +31,7 @@ export class HasDataChannelMatcher extends HasDataChannelMatcherDefinition {
 
 }
 
-export class HasVideoTrackMatcher extends HasVideoTrackMatcherDefinition {
+export class HasVideoTrackMatcherImpl extends HasVideoTrackMatcher {
 
     matches(connection: RTCConnection): boolean {
         return [
@@ -42,7 +42,7 @@ export class HasVideoTrackMatcher extends HasVideoTrackMatcherDefinition {
 
 }
 
-export class HasAudioTrackMatcher extends HasAudioTrackMatcherDefinition {
+export class HasAudioTrackMatcherImpl extends HasAudioTrackMatcher {
 
     matches(connection: RTCConnection): boolean {
         return [
@@ -53,7 +53,7 @@ export class HasAudioTrackMatcher extends HasAudioTrackMatcherDefinition {
 
 }
 
-export class HasMediaTrackMatcher extends HasMediaTrackMatcherDefinition {
+export class HasMediaTrackMatcherImpl extends HasMediaTrackMatcher {
 
     matches(connection: RTCConnection): boolean {
         return [
@@ -76,7 +76,7 @@ const getConnectionSourceURL = (connection: RTCConnection): URL | undefined => {
     }
 };
 
-export class HostnameMatcher extends HostnameMatcherDefinition {
+export class HostnameMatcherImpl extends HostnameMatcher {
 
     matches(connection: RTCConnection): boolean {
         const url = getConnectionSourceURL(connection);
@@ -85,7 +85,7 @@ export class HostnameMatcher extends HostnameMatcherDefinition {
 
 }
 
-export class UrlRegexMatcher extends UrlRegexMatcherDefinition {
+export class UrlRegexMatcherImpl extends UrlRegexMatcher {
 
     matches(connection: RTCConnection): boolean {
         const url = getConnectionSourceURL(connection);
@@ -96,7 +96,7 @@ export class UrlRegexMatcher extends UrlRegexMatcherDefinition {
 
 }
 
-export class UserAgentRegexMatcher extends UserAgentRegexMatcherDefinition {
+export class UserAgentRegexMatcherImpl extends UserAgentRegexMatcher {
 
     matches(connection: RTCConnection): boolean {
         const userAgent = connection.metadata.userAgent;
@@ -108,11 +108,11 @@ export class UserAgentRegexMatcher extends UserAgentRegexMatcherDefinition {
 }
 
 export const MatcherLookup: typeof MatcherDefinitionLookup = {
-    'has-rtc-data-channel': HasDataChannelMatcher,
-    'has-rtc-video-track': HasVideoTrackMatcher,
-    'has-rtc-audio-track': HasAudioTrackMatcher,
-    'has-rtc-media-track': HasMediaTrackMatcher,
-    'rtc-page-hostname': HostnameMatcher,
-    'rtc-page-regex': UrlRegexMatcher,
-    'rtc-user-agent-regex': UserAgentRegexMatcher
+    'has-rtc-data-channel': HasDataChannelMatcherImpl,
+    'has-rtc-video-track': HasVideoTrackMatcherImpl,
+    'has-rtc-audio-track': HasAudioTrackMatcherImpl,
+    'has-rtc-media-track': HasMediaTrackMatcherImpl,
+    'rtc-page-hostname': HostnameMatcherImpl,
+    'rtc-page-regex': UrlRegexMatcherImpl,
+    'rtc-user-agent-regex': UserAgentRegexMatcherImpl
 };

package/src/rule-builder.ts

@@ -7,13 +7,13 @@ import { MockRTCHandlerBuilder } from "./handling/handler-builder";
 import { HandlerStepDefinition } from "./handling/handler-step-definitions";
 import {
     MatcherDefinition,
-    HostnameMatcherDefinition,
-    UrlRegexMatcherDefinition,
-    UserAgentRegexMatcherDefinition,
-    HasAudioTrackMatcherDefinition,
-    HasVideoTrackMatcherDefinition,
-    HasMediaTrackMatcherDefinition,
-    HasDataChannelMatcherDefinition
+    HostnameMatcher,
+    UrlRegexMatcher,
+    UserAgentRegexMatcher,
+    HasAudioTrackMatcher,
+    HasVideoTrackMatcher,
+    HasMediaTrackMatcher,
+    HasDataChannelMatcher
 } from "./matching/matcher-definitions";
 
 export type RuleHandlerBuilder = MockRTCHandlerBuilder<void>;
@@ -38,7 +38,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * Match RTC connections whose initial negotiation includes a data channel.
      */
     withDataChannels() {
-        this.matchers.push(new HasDataChannelMatcherDefinition());
+        this.matchers.push(new HasDataChannelMatcher());
         return this;
     }
 
@@ -47,7 +47,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * media track.
      */
     withMedia() {
-        this.matchers.push(new HasMediaTrackMatcherDefinition());
+        this.matchers.push(new HasMediaTrackMatcher());
         return this;
     }
 
@@ -55,7 +55,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * Match RTC connections whose initial negotiation includes a video media track
      */
     withVideo() {
-        this.matchers.push(new HasVideoTrackMatcherDefinition());
+        this.matchers.push(new HasVideoTrackMatcher());
         return this;
     }
 
@@ -63,7 +63,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * Match RTC connections whose initial negotiation includes an audio media track
      */
     withAudio() {
-        this.matchers.push(new HasAudioTrackMatcherDefinition());
+        this.matchers.push(new HasAudioTrackMatcher());
         return this;
     }
 
@@ -78,7 +78,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * @category Matcher
      */
     fromPageHostname(hostname: string): this {
-        this.matchers.push(new HostnameMatcherDefinition(hostname));
+        this.matchers.push(new HostnameMatcher(hostname));
         return this;
     }
 
@@ -93,7 +93,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * @category Matcher
      */
     fromPageUrlMatching(urlRegex: RegExp): this {
-        this.matchers.push(new UrlRegexMatcherDefinition(urlRegex));
+        this.matchers.push(new UrlRegexMatcher(urlRegex));
         return this;
     }
 
@@ -109,7 +109,7 @@ export class MockRTCRuleBuilder implements Omit<RuleHandlerBuilder, 'handlerStep
      * @category Matcher
      */
     fromUserAgentMatching(userAgentRegEx: RegExp): this {
-        this.matchers.push(new UserAgentRegexMatcherDefinition(userAgentRegEx));
+        this.matchers.push(new UserAgentRegexMatcher(userAgentRegEx));
         return this;
     }
 

package/src/server/mockrtc-admin-plugin.ts

@@ -10,12 +10,12 @@ import { PluggableAdmin } from 'mockttp';
 import type { IResolvers } from "@graphql-tools/utils";
 import { PubSub } from "graphql-subscriptions";
 
-import { StepLookup } from '../handling/handler-steps';
+import { StepLookup } from '../handling/handler-step-impls';
 import { MockRTCOptions, MockRTCSessionDescription } from '../mockrtc';
 import { MockRTCServer } from './mockrtc-server';
 import { AnswerOptions, OfferOptions } from '../mockrtc-peer';
 import { MatcherDefinition } from '../matching/matcher-definitions';
-import { MatcherLookup } from '../matching/matchers';
+import { MatcherLookup } from '../matching/matcher-impls';
 import { HandlerStepDefinition } from '../handling/handler-step-definitions';
 
 const { deserialize } = PluggableAdmin.Serialization;
@@ -225,7 +225,7 @@ export class MockRTCAdminPlugin implements PluggableAdmin.AdminPlugin<MockRTCOpt
         }
     `;
 
-    buildResolvers(adminStream: stream.Duplex, ruleParams: {}): IResolvers {
+    buildResolvers(adminStream: stream.Duplex): IResolvers {
         const pubsub = new PubSub();
 
         EVENTS.forEach((eventName) => {
@@ -241,7 +241,7 @@ export class MockRTCAdminPlugin implements PluggableAdmin.AdminPlugin<MockRTCOpt
                 } }) => {
                     return this.mockRTCServer.buildPeerFromDefinition(
                         steps.map((stepData) =>
-                            deserialize(stepData, adminStream, ruleParams, StepLookup)
+                            deserialize(stepData, adminStream, {}, StepLookup)
                         )
                     );
                 },
@@ -251,10 +251,10 @@ export class MockRTCAdminPlugin implements PluggableAdmin.AdminPlugin<MockRTCOpt
                 } }) => {
                     return this.mockRTCServer.addRuleFromDefinition(
                         matchers.map((matcherData) =>
-                            deserialize(matcherData, adminStream, ruleParams, MatcherLookup)
+                            deserialize(matcherData, adminStream, {}, MatcherLookup)
                         ),
                         steps.map((stepData) =>
-                            deserialize(stepData, adminStream, ruleParams, StepLookup)
+                            deserialize(stepData, adminStream, {}, StepLookup)
                         )
                     );
                 },
@@ -265,10 +265,10 @@ export class MockRTCAdminPlugin implements PluggableAdmin.AdminPlugin<MockRTCOpt
                     return this.mockRTCServer.setRulesFromDefinitions(
                         rules.map(({ matchers, steps }) => ({
                             matchers: matchers.map((matcherData) =>
-                                deserialize(matcherData, adminStream, ruleParams, MatcherLookup)
+                                deserialize(matcherData, adminStream, {}, MatcherLookup)
                             ),
                             steps: steps.map((stepData) =>
-                                deserialize(stepData, adminStream, ruleParams, StepLookup)
+                                deserialize(stepData, adminStream, {}, StepLookup)
                             )
                         }))
                     );

package/src/server/mockrtc-server-peer.ts

@@ -18,7 +18,7 @@ import {
     OfferOptions,
     AnswerOptions
 } from "../mockrtc-peer";
-import { HandlerStep } from '../handling/handler-steps';
+import { HandlerStepImpl } from '../handling/handler-step-impls';
 
 import { RTCConnection } from '../webrtc/rtc-connection';
 import { MockRTCConnection } from '../webrtc/mockrtc-connection';
@@ -28,7 +28,7 @@ import { TimingEvents } from '../mockrtc';
 
 export class MockRTCServerPeer implements MockRTCPeer {
 
-    readonly peerId = randomUUID();
+    readonly peerId: string = randomUUID();
 
     private debug: boolean = false;
 
@@ -40,7 +40,7 @@ export class MockRTCServerPeer implements MockRTCPeer {
 
     constructor(
         private getHandlerSteps: (conn: RTCConnection) =>
-            (HandlerStep[] | Promise<HandlerStep[]>),
+            (HandlerStepImpl[] | Promise<HandlerStepImpl[]>),
         private options: MockRTCPeerOptions & { peerId?: string } = {},
         private eventEmitter: EventEmitter
     ) {

package/src/server/mockrtc-server.ts

@@ -12,9 +12,9 @@ import { MockRTCPeer } from "../mockrtc-peer";
 import { RTCConnection } from "../webrtc/rtc-connection";
 
 import type { MatcherDefinition } from "../matching/matcher-definitions";
-import { Matcher, MatcherLookup } from "../matching/matchers";
+import { MatcherImpl, MatcherLookup } from "../matching/matcher-impls";
 import type { HandlerStepDefinition } from "../handling/handler-step-definitions";
-import { DynamicProxyStep, HandlerStep, StepLookup } from "../handling/handler-steps";
+import { DynamicProxyStepImpl, HandlerStepImpl, StepLookup } from "../handling/handler-step-impls";
 
 const MATCHING_PEER_ID = 'matching-peer';
 
@@ -86,8 +86,8 @@ export class MockRTCServer extends MockRTCBase implements MockRTC {
     }
 
     private rules: Array<{
-        matchers: Matcher[],
-        handlerSteps: HandlerStep[]
+        matchers: MatcherImpl[],
+        handlerSteps: HandlerStepImpl[]
     }> = [];
 
     async setRulesFromDefinitions(
@@ -106,14 +106,14 @@ export class MockRTCServer extends MockRTCBase implements MockRTC {
         matcherDefinitions: MatcherDefinition[],
         handlerStepDefinitions: HandlerStepDefinition[]
     ) {
-        const matchers = matcherDefinitions.map((definition): Matcher => {
+        const matchers = matcherDefinitions.map((definition): MatcherImpl => {
             return Object.assign(
                 Object.create(MatcherLookup[definition.type].prototype),
                 definition
             );
         });
 
-        const handlerSteps = handlerStepDefinitions.map((definition): HandlerStep => {
+        const handlerSteps = handlerStepDefinitions.map((definition): HandlerStepImpl => {
             return Object.assign(
                 Object.create(StepLookup[definition.type].prototype),
                 definition
@@ -143,13 +143,13 @@ export class MockRTCServer extends MockRTCBase implements MockRTC {
 
         // Unmatched connections are proxied dynamically. In practice, that means they're accepted
         // and ignored initially, unless an external peer also connects and is attached:
-        return [new DynamicProxyStep()];
+        return [new DynamicProxyStepImpl()];
     }
 
     // Peer definition API:
 
     async buildPeerFromDefinition(handlerStepDefinitions: HandlerStepDefinition[]): Promise<MockRTCServerPeer> {
-        const handlerSteps = handlerStepDefinitions.map((definition): HandlerStep => {
+        const handlerSteps = handlerStepDefinitions.map((definition): HandlerStepImpl => {
             return Object.assign(
                 Object.create(StepLookup[definition.type].prototype),
                 definition

package/src/webrtc/mockrtc-connection.ts

@@ -90,6 +90,7 @@ export class MockRTCConnection extends RTCConnection {
         }
 
         await this.proxyTrafficTo(this.externalConnection!);
+        return this.externalConnection!;
     }
 
     async proxyTrafficTo(externalConnection: RTCConnection) {