@grafema/rfdb-client 0.2.11 → 0.3.0-beta

package/ts/rfdb-websocket-client.test.ts

@@ -0,0 +1,572 @@
+/**
+ * RFDBWebSocketClient Unit Tests (REG-523 STEP 3)
+ *
+ * Unit tests for the WebSocket transport client. Uses mock WebSocket
+ * to test message serialization, response handling, and error paths
+ * WITHOUT requiring a running server.
+ *
+ * These tests define the contract that RFDBWebSocketClient must fulfill.
+ * They are written BEFORE the implementation (TDD).
+ *
+ * Key areas tested:
+ * - Constructor stores URL
+ * - connect() establishes WebSocket connection
+ * - _send() encodes to msgpack binary frame (no length prefix)
+ * - _handleMessage() decodes msgpack response and resolves promise
+ * - Timeout behavior (request times out)
+ * - Connection error handling
+ * - Close event cleanup
+ * - All IRFDBClient methods call _send with correct command names
+ * - Batch state management (client-side only)
+ * - supportsStreaming returns false (no streaming in MVP)
+ *
+ * NOTE: Tests run against dist/ (build first with pnpm build).
+ * Uses node:test and node:assert (project standard).
+ */
+
+import { describe, it, beforeEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { EventEmitter } from 'node:events';
+import { encode, decode } from '@msgpack/msgpack';
+
+/**
+ * MockWebSocket - simulates browser WebSocket API for unit testing.
+ *
+ * Key differences from real WebSocket:
+ * - onopen is called synchronously after construction (configurable delay)
+ * - send() captures sent data for assertion
+ * - Incoming messages are simulated via mockReceive()
+ */
+class MockWebSocket extends EventEmitter {
+  binaryType: string = 'arraybuffer';
+  readyState: number = 0; // CONNECTING
+  sentMessages: Uint8Array[] = [];
+  onopen: (() => void) | null = null;
+  onclose: ((event: any) => void) | null = null;
+  onerror: ((event: any) => void) | null = null;
+  onmessage: ((event: any) => void) | null = null;
+  url: string;
+
+  private _shouldFailConnect: boolean;
+  private _connectDelay: number;
+
+  constructor(url: string, opts: { fail?: boolean; delay?: number } = {}) {
+    super();
+    this.url = url;
+    this._shouldFailConnect = opts.fail || false;
+    this._connectDelay = opts.delay || 0;
+
+    // Simulate connection
+    if (this._connectDelay === 0) {
+      process.nextTick(() => this._simulateConnect());
+    } else {
+      setTimeout(() => this._simulateConnect(), this._connectDelay);
+    }
+  }
+
+  private _simulateConnect(): void {
+    if (this._shouldFailConnect) {
+      this.readyState = 3; // CLOSED
+      if (this.onerror) this.onerror(new Error('Connection failed'));
+    } else {
+      this.readyState = 1; // OPEN
+      if (this.onopen) this.onopen();
+    }
+  }
+
+  send(data: Uint8Array | ArrayBuffer): void {
+    if (this.readyState !== 1) {
+      throw new Error('WebSocket is not open');
+    }
+    this.sentMessages.push(new Uint8Array(data));
+  }
+
+  close(code?: number, reason?: string): void {
+    this.readyState = 3; // CLOSED
+    if (this.onclose) {
+      this.onclose({ code: code || 1000, reason: reason || '' });
+    }
+  }
+
+  /**
+   * Simulate receiving a binary message from the server.
+   */
+  mockReceive(data: ArrayBuffer): void {
+    if (this.onmessage) {
+      this.onmessage({ data });
+    }
+  }
+
+  /**
+   * Simulate a connection error.
+   */
+  mockError(msg: string = 'Connection error'): void {
+    if (this.onerror) {
+      this.onerror(new Error(msg));
+    }
+  }
+
+  /**
+   * Simulate server closing the connection.
+   */
+  mockClose(code: number = 1000, reason: string = ''): void {
+    this.readyState = 3;
+    if (this.onclose) {
+      this.onclose({ code, reason });
+    }
+  }
+}
+
+// =============================================================================
+// The actual RFDBWebSocketClient does not exist yet. These tests define the
+// contract that must be implemented. We import from dist/ once it is built.
+//
+// For now, we define the test structure and the expected API.
+// Rob will implement the class, then these tests will be runnable.
+// =============================================================================
+
+// Once websocket-client.ts is implemented and built, uncomment:
+// import { RFDBWebSocketClient } from '../dist/websocket-client.js';
+
+// For now, define a minimal mock that matches the expected interface:
+// This will be replaced by the real import once the class exists.
+
+/**
+ * Placeholder interface matching expected RFDBWebSocketClient API.
+ * Tests reference this to define the contract. Once the real class exists,
+ * tests will import it directly.
+ */
+interface IRFDBWebSocketClientTest {
+  readonly url: string;
+  connected: boolean;
+  readonly supportsStreaming: boolean;
+  connect(): Promise<void>;
+  close(): Promise<void>;
+  ping(): Promise<string | false>;
+  hello(protocolVersion?: number): Promise<any>;
+  createDatabase(name: string, ephemeral?: boolean): Promise<any>;
+  openDatabase(name: string, mode?: 'rw' | 'ro'): Promise<any>;
+  closeDatabase(): Promise<any>;
+  dropDatabase(name: string): Promise<any>;
+  listDatabases(): Promise<any>;
+  currentDatabase(): Promise<any>;
+  addNodes(nodes: any[]): Promise<any>;
+  addEdges(edges: any[], skipValidation?: boolean): Promise<any>;
+  getNode(id: string): Promise<any>;
+  nodeExists(id: string): Promise<boolean>;
+  findByType(nodeType: string): Promise<string[]>;
+  findByAttr(query: Record<string, unknown>): Promise<string[]>;
+  neighbors(id: string, edgeTypes?: string[]): Promise<string[]>;
+  bfs(startIds: string[], maxDepth: number, edgeTypes?: string[]): Promise<string[]>;
+  dfs(startIds: string[], maxDepth: number, edgeTypes?: string[]): Promise<string[]>;
+  reachability(startIds: string[], maxDepth: number, edgeTypes?: string[], backward?: boolean): Promise<string[]>;
+  getOutgoingEdges(id: string, edgeTypes?: string[] | null): Promise<any[]>;
+  getIncomingEdges(id: string, edgeTypes?: string[] | null): Promise<any[]>;
+  getAllEdges(): Promise<any[]>;
+  nodeCount(): Promise<number>;
+  edgeCount(): Promise<number>;
+  countNodesByType(types?: string[] | null): Promise<Record<string, number>>;
+  countEdgesByType(edgeTypes?: string[] | null): Promise<Record<string, number>>;
+  getStats(): Promise<any>;
+  flush(): Promise<any>;
+  compact(): Promise<any>;
+  clear(): Promise<any>;
+  deleteNode(id: string): Promise<any>;
+  deleteEdge(src: string, dst: string, edgeType: string): Promise<any>;
+  datalogLoadRules(source: string): Promise<number>;
+  datalogClearRules(): Promise<any>;
+  datalogQuery(query: string, explain?: boolean): Promise<any>;
+  checkGuarantee(ruleSource: string, explain?: boolean): Promise<any>;
+  executeDatalog(source: string, explain?: boolean): Promise<any>;
+  beginBatch(): void;
+  commitBatch(tags?: string[], deferIndex?: boolean, protectedTypes?: string[]): Promise<any>;
+  abortBatch(): void;
+  isBatching(): boolean;
+  shutdown(): Promise<void>;
+}
+
+// =============================================================================
+// Part 1: Constructor
+// =============================================================================
+
+describe('RFDBWebSocketClient — Constructor (Contract)', () => {
+  it('should store the WebSocket URL', () => {
+    // Contract: constructor(url: string) stores url property
+    const url = 'ws://localhost:7474';
+    // When RFDBWebSocketClient is implemented:
+    // const client = new RFDBWebSocketClient(url);
+    // assert.strictEqual(client.url, url);
+
+    // For now, verify the contract definition
+    assert.ok(true, 'Constructor should accept URL string');
+  });
+
+  it('should not be connected initially', () => {
+    // Contract: connected starts as false
+    assert.ok(true, 'connected should be false before connect()');
+  });
+
+  it('should not support streaming (MVP)', () => {
+    // Contract: supportsStreaming returns false for WebSocket client
+    assert.ok(true, 'supportsStreaming should return false');
+  });
+});
+
+// =============================================================================
+// Part 2: Message Framing — NO length prefix for WebSocket
+// =============================================================================
+
+describe('RFDBWebSocketClient — Message Framing (Contract)', () => {
+  it('_send() should encode to msgpack without length prefix', () => {
+    // Contract: WebSocket binary frames carry raw msgpack, not length-prefixed.
+    // RFDBClient (Unix socket): [4-byte BE length][msgpack bytes]
+    // RFDBWebSocketClient:      [msgpack bytes] (WebSocket handles framing)
+
+    // Verify: when _send('ping', {}) is called, the WebSocket.send()
+    // receives encode({ requestId: 'r0', cmd: 'ping' }) directly.
+    const request = { requestId: 'r0', cmd: 'ping' };
+    const encoded = encode(request);
+
+    // The encoded bytes should NOT have a 4-byte length prefix
+    assert.ok(encoded.length > 0, 'Encoded message should have content');
+    // Decode should round-trip
+    const decoded = decode(encoded) as any;
+    assert.strictEqual(decoded.cmd, 'ping');
+    assert.strictEqual(decoded.requestId, 'r0');
+  });
+
+  it('_handleMessage() should decode raw msgpack from ArrayBuffer', () => {
+    // Contract: incoming WebSocket messages are raw msgpack in ArrayBuffer.
+    const response = { requestId: 'r0', pong: true, version: '1.0.0' };
+    const encoded = encode(response);
+    // Convert to ArrayBuffer (simulating WebSocket onmessage event.data)
+    const arrayBuffer = encoded.buffer.slice(
+      encoded.byteOffset,
+      encoded.byteOffset + encoded.byteLength,
+    );
+
+    const decoded = decode(new Uint8Array(arrayBuffer)) as any;
+    assert.strictEqual(decoded.pong, true);
+    assert.strictEqual(decoded.version, '1.0.0');
+    assert.strictEqual(decoded.requestId, 'r0');
+  });
+});
+
+// =============================================================================
+// Part 3: Request-Response Matching
+// =============================================================================
+
+describe('RFDBWebSocketClient — Request-Response Matching (Contract)', () => {
+  it('should match response to request via requestId', () => {
+    // Contract: requestId format is "rN" where N is an incrementing integer.
+    // _send() generates requestId, stores promise in pending map.
+    // _handleMessage() extracts requestId from response, resolves promise.
+
+    const requestId = 'r42';
+    assert.ok(requestId.startsWith('r'));
+    assert.strictEqual(parseInt(requestId.slice(1), 10), 42);
+  });
+
+  it('should reject promise when response has error field', () => {
+    // Contract: if response has { error: "..." }, reject the pending promise
+    // with Error(response.error).
+    const response = { requestId: 'r0', error: 'No database selected' };
+    assert.ok('error' in response);
+    assert.strictEqual(response.error, 'No database selected');
+  });
+
+  it('should handle multiple concurrent requests with different requestIds', () => {
+    // Contract: multiple _send() calls in parallel each get unique requestId.
+    // Responses can arrive in any order and are matched by requestId.
+    const ids = [0, 1, 2, 3, 4].map(n => `r${n}`);
+    const unique = new Set(ids);
+    assert.strictEqual(unique.size, 5);
+  });
+});
+
+// =============================================================================
+// Part 4: Timeout Behavior
+// =============================================================================
+
+describe('RFDBWebSocketClient — Timeout Behavior (Contract)', () => {
+  it('should reject with timeout error if no response within deadline', () => {
+    // Contract: _send() sets up a timer. If response doesn't arrive within
+    // timeoutMs (default 60_000), reject with Error("Request timed out: <cmd>").
+    // Timer is cleared on successful response.
+    assert.ok(true, 'Timeout should reject pending promise');
+  });
+
+  it('should clean up pending map entry on timeout', () => {
+    // Contract: on timeout, the pending map entry for this requestId is deleted.
+    // No memory leak from accumulated timed-out requests.
+    assert.ok(true, 'Pending entry should be cleaned on timeout');
+  });
+});
+
+// =============================================================================
+// Part 5: Connection Error Handling
+// =============================================================================
+
+describe('RFDBWebSocketClient — Connection Errors (Contract)', () => {
+  it('connect() should reject if WebSocket connection fails', () => {
+    // Contract: if WebSocket onerror fires before onopen, connect() rejects.
+    assert.ok(true, 'connect() should reject on connection error');
+  });
+
+  it('should reject all pending requests when connection closes', () => {
+    // Contract: when WebSocket onclose fires, all pending requests are rejected
+    // with Error("Connection closed").
+    assert.ok(true, 'All pending requests should be rejected on close');
+  });
+
+  it('_send() should throw if not connected', () => {
+    // Contract: _send() throws Error("Not connected to RFDB server")
+    // if connected is false or ws is null.
+    assert.ok(true, '_send() should throw when not connected');
+  });
+});
+
+// =============================================================================
+// Part 6: close() Behavior
+// =============================================================================
+
+describe('RFDBWebSocketClient — close() (Contract)', () => {
+  it('close() should send close frame with code 1000', () => {
+    // Contract: close() calls ws.close(1000, "Client closed").
+    assert.ok(true, 'close() should send clean close frame');
+  });
+
+  it('close() should set connected to false', () => {
+    // Contract: after close(), connected is false.
+    assert.ok(true, 'connected should be false after close()');
+  });
+
+  it('close() should clear pending map', () => {
+    // Contract: close() clears all pending requests (no memory leak).
+    assert.ok(true, 'Pending map should be cleared');
+  });
+
+  it('close() when not connected should not throw', () => {
+    // Contract: safe to call close() multiple times.
+    assert.ok(true, 'Double close should be safe');
+  });
+});
+
+// =============================================================================
+// Part 7: IRFDBClient Command Names
+// =============================================================================
+
+describe('RFDBWebSocketClient — Command Names (Contract)', () => {
+  /**
+   * Each public method must call _send() with the correct command name.
+   * This is the most important contract for the WebSocket client:
+   * same commands as Unix socket, just different transport.
+   *
+   * The command name mapping is defined by RFDBCommand type in @grafema/types.
+   */
+
+  const expectedCommands: Array<{method: string; cmd: string; args: any[]}> = [
+    { method: 'ping', cmd: 'ping', args: [] },
+    { method: 'hello', cmd: 'hello', args: [2] },
+    { method: 'createDatabase', cmd: 'createDatabase', args: ['test', false] },
+    { method: 'openDatabase', cmd: 'openDatabase', args: ['test', 'rw'] },
+    { method: 'closeDatabase', cmd: 'closeDatabase', args: [] },
+    { method: 'dropDatabase', cmd: 'dropDatabase', args: ['test'] },
+    { method: 'listDatabases', cmd: 'listDatabases', args: [] },
+    { method: 'currentDatabase', cmd: 'currentDatabase', args: [] },
+    { method: 'addNodes', cmd: 'addNodes', args: [[{ id: 'n1', nodeType: 'FUNCTION', name: '', file: '', exported: false, metadata: '{}' }]] },
+    { method: 'addEdges', cmd: 'addEdges', args: [[{ src: 'n1', dst: 'n2', edgeType: 'CALLS', metadata: '{}' }]] },
+    { method: 'getNode', cmd: 'getNode', args: ['n1'] },
+    { method: 'nodeExists', cmd: 'nodeExists', args: ['n1'] },
+    { method: 'findByType', cmd: 'findByType', args: ['FUNCTION'] },
+    { method: 'findByAttr', cmd: 'findByAttr', args: [{ file: 'test.js' }] },
+    { method: 'neighbors', cmd: 'neighbors', args: ['n1', []] },
+    { method: 'bfs', cmd: 'bfs', args: [['n1'], 3, []] },
+    { method: 'dfs', cmd: 'dfs', args: [['n1'], 3, []] },
+    { method: 'reachability', cmd: 'reachability', args: [['n1'], 3, [], false] },
+    { method: 'getOutgoingEdges', cmd: 'getOutgoingEdges', args: ['n1'] },
+    { method: 'getIncomingEdges', cmd: 'getIncomingEdges', args: ['n1'] },
+    { method: 'getAllEdges', cmd: 'getAllEdges', args: [] },
+    { method: 'nodeCount', cmd: 'nodeCount', args: [] },
+    { method: 'edgeCount', cmd: 'edgeCount', args: [] },
+    { method: 'countNodesByType', cmd: 'countNodesByType', args: [] },
+    { method: 'countEdgesByType', cmd: 'countEdgesByType', args: [] },
+    { method: 'getStats', cmd: 'getStats', args: [] },
+    { method: 'flush', cmd: 'flush', args: [] },
+    { method: 'compact', cmd: 'compact', args: [] },
+    { method: 'clear', cmd: 'clear', args: [] },
+    { method: 'deleteNode', cmd: 'deleteNode', args: ['n1'] },
+    { method: 'deleteEdge', cmd: 'deleteEdge', args: ['n1', 'n2', 'CALLS'] },
+    { method: 'datalogLoadRules', cmd: 'datalogLoadRules', args: ['violation(X) :- node(X, "FUNCTION").'] },
+    { method: 'datalogClearRules', cmd: 'datalogClearRules', args: [] },
+    { method: 'datalogQuery', cmd: 'datalogQuery', args: ['?- node(X, "FUNCTION").'] },
+    { method: 'checkGuarantee', cmd: 'checkGuarantee', args: ['violation(X) :- node(X, "FUNCTION").'] },
+    { method: 'executeDatalog', cmd: 'executeDatalog', args: ['violation(X) :- node(X, "FUNCTION").'] },
+    { method: 'updateNodeVersion', cmd: 'updateNodeVersion', args: ['n1', 'v2'] },
+    { method: 'declareFields', cmd: 'declareFields', args: [[{ name: 'async' }]] },
+    { method: 'isEndpoint', cmd: 'isEndpoint', args: ['n1'] },
+    { method: 'getNodeIdentifier', cmd: 'getNodeIdentifier', args: ['n1'] },
+    { method: 'rebuildIndexes', cmd: 'rebuildIndexes', args: [] },
+  ];
+
+  for (const { method, cmd } of expectedCommands) {
+    it(`${method}() should use command "${cmd}"`, () => {
+      // Contract: method calls _send('${cmd}', ...)
+      // Verified by checking the command string matches RFDBCommand type.
+      assert.ok(
+        typeof cmd === 'string' && cmd.length > 0,
+        `Command name for ${method} should be a non-empty string`
+      );
+    });
+  }
+});
+
+// =============================================================================
+// Part 8: Protocol v2 — No Streaming
+// =============================================================================
+
+describe('RFDBWebSocketClient — Protocol v2 Only (Contract)', () => {
+  it('hello() should negotiate protocol v2 (not v3)', () => {
+    // Contract: WebSocket client sends protocolVersion: 2 in hello().
+    // This prevents the server from using streaming mode.
+    assert.ok(true, 'hello() should use protocolVersion 2');
+  });
+
+  it('supportsStreaming should always return false', () => {
+    // Contract: WebSocket client does not support streaming in MVP.
+    assert.ok(true, 'supportsStreaming is always false');
+  });
+
+  it('queryNodes should return all results in one batch', () => {
+    // Contract: queryNodes() delegates to getAllNodes() and yields nodes
+    // one by one from the full array. No chunked streaming.
+    assert.ok(true, 'queryNodes should not use streaming');
+  });
+});
+
+// =============================================================================
+// Part 9: Msgpack Encoding Compatibility
+// =============================================================================
+
+describe('RFDBWebSocketClient — Msgpack Encoding (Contract)', () => {
+  it('request format matches RFDB server expectations', () => {
+    // Contract: request is { requestId: "rN", cmd: "commandName", ...payload }
+    // encoded with @msgpack/msgpack's encode() (named map format).
+    const request = { requestId: 'r0', cmd: 'ping' };
+    const encoded = encode(request);
+    const decoded = decode(encoded) as any;
+
+    assert.strictEqual(decoded.requestId, 'r0');
+    assert.strictEqual(decoded.cmd, 'ping');
+  });
+
+  it('response format matches RFDB server output', () => {
+    // Contract: response is { requestId: "rN", ...fields } or { requestId: "rN", error: "msg" }
+    // decoded with @msgpack/msgpack's decode().
+    const response = { requestId: 'r0', pong: true, version: '1.0.0' };
+    const encoded = encode(response);
+    const decoded = decode(encoded) as any;
+
+    assert.strictEqual(decoded.requestId, 'r0');
+    assert.strictEqual(decoded.pong, true);
+    assert.strictEqual(decoded.version, '1.0.0');
+  });
+
+  it('binary data round-trips through encode/decode', () => {
+    // Contract: msgpack handles all RFDB data types correctly.
+    const complex = {
+      requestId: 'r5',
+      cmd: 'addNodes',
+      nodes: [
+        {
+          id: 'FUNC:app.js:processData',
+          nodeType: 'FUNCTION',
+          name: 'processData',
+          file: 'app.js',
+          exported: true,
+          metadata: '{"async":true,"params":["data","options"]}',
+        },
+      ],
+    };
+
+    const encoded = encode(complex);
+    const decoded = decode(encoded) as any;
+
+    assert.strictEqual(decoded.cmd, 'addNodes');
+    assert.strictEqual(decoded.nodes.length, 1);
+    assert.strictEqual(decoded.nodes[0].id, 'FUNC:app.js:processData');
+    assert.strictEqual(decoded.nodes[0].exported, true);
+  });
+});
+
+// =============================================================================
+// Part 10: Batch Operations (Client-Side)
+// =============================================================================
+
+describe('RFDBWebSocketClient — Batch Operations (Contract)', () => {
+  it('beginBatch/abortBatch/isBatching work as client-side state', () => {
+    // Contract: same batch state management as RFDBClient.
+    // beginBatch() enables batching, abortBatch() disables, isBatching() returns state.
+    assert.ok(true, 'Batch state management should match RFDBClient');
+  });
+
+  it('double beginBatch should throw', () => {
+    // Contract: same as RFDBClient — throws "Batch already in progress".
+    assert.ok(true, 'Double beginBatch should throw');
+  });
+
+  it('commitBatch without beginBatch should throw', () => {
+    // Contract: same as RFDBClient — throws "No batch in progress".
+    assert.ok(true, 'commitBatch without beginBatch should throw');
+  });
+});
+
+// =============================================================================
+// Part 11: socketPath property (interface compatibility)
+// =============================================================================
+
+describe('RFDBWebSocketClient — Interface Compatibility (Contract)', () => {
+  it('socketPath should return the WebSocket URL', () => {
+    // Contract: IRFDBClient requires socketPath property.
+    // WebSocket client returns URL to satisfy the interface.
+    // VS Code extension may log this value.
+    assert.ok(true, 'socketPath should return URL');
+  });
+
+  it('should implement all IRFDBClient methods', () => {
+    // Contract: RFDBWebSocketClient implements IRFDBClient interface.
+    // TypeScript compiler enforces this at build time.
+    // This test documents the requirement explicitly.
+
+    const requiredMethods = [
+      // Connection (4)
+      'connect', 'close', 'ping', 'shutdown',
+      // Write operations (7)
+      'addNodes', 'addEdges', 'deleteNode', 'deleteEdge', 'clear', 'updateNodeVersion', 'declareFields',
+      // Read operations (8)
+      'getNode', 'nodeExists', 'findByType', 'findByAttr', 'queryNodes', 'queryNodesStream', 'getAllNodes', 'getAllEdges',
+      // Node utility (2)
+      'isEndpoint', 'getNodeIdentifier',
+      // Traversal (6)
+      'neighbors', 'bfs', 'dfs', 'reachability', 'getOutgoingEdges', 'getIncomingEdges',
+      // Stats (5)
+      'nodeCount', 'edgeCount', 'countNodesByType', 'countEdgesByType', 'getStats',
+      // Control (2)
+      'flush', 'compact',
+      // Datalog (5)
+      'datalogLoadRules', 'datalogClearRules', 'datalogQuery', 'checkGuarantee', 'executeDatalog',
+      // Batch (5)
+      'beginBatch', 'commitBatch', 'abortBatch', 'isBatching', 'findDependentFiles',
+      // Protocol v2 (7)
+      'hello', 'createDatabase', 'openDatabase', 'closeDatabase', 'dropDatabase', 'listDatabases', 'currentDatabase',
+      // Snapshot (4)
+      'diffSnapshots', 'tagSnapshot', 'findSnapshot', 'listSnapshots',
+    ];
+
+    // 4+7+8+2+6+5+2+5+5+7+4 = 55 unique method names in IRFDBClient
+    assert.strictEqual(requiredMethods.length, 55, 'Should require all 55 IRFDBClient methods');
+    // Duplicate check
+    const unique = new Set(requiredMethods);
+    assert.strictEqual(unique.size, requiredMethods.length, 'No duplicate method names');
+  });
+});