Relocate tests under /test (#1220)

test/inMemory.test.ts

@@ -0,0 +1,119 @@
+import { InMemoryTransport } from '../src/inMemory.js';
+import { JSONRPCMessage } from '../src/types.js';
+import { AuthInfo } from '../src/server/auth/types.js';
+
+describe('InMemoryTransport', () => {
+    let clientTransport: InMemoryTransport;
+    let serverTransport: InMemoryTransport;
+
+    beforeEach(() => {
+        [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    });
+
+    test('should create linked pair', () => {
+        expect(clientTransport).toBeDefined();
+        expect(serverTransport).toBeDefined();
+    });
+
+    test('should start without error', async () => {
+        await expect(clientTransport.start()).resolves.not.toThrow();
+        await expect(serverTransport.start()).resolves.not.toThrow();
+    });
+
+    test('should send message from client to server', async () => {
+        const message: JSONRPCMessage = {
+            jsonrpc: '2.0',
+            method: 'test',
+            id: 1
+        };
+
+        let receivedMessage: JSONRPCMessage | undefined;
+        serverTransport.onmessage = msg => {
+            receivedMessage = msg;
+        };
+
+        await clientTransport.send(message);
+        expect(receivedMessage).toEqual(message);
+    });
+
+    test('should send message with auth info from client to server', async () => {
+        const message: JSONRPCMessage = {
+            jsonrpc: '2.0',
+            method: 'test',
+            id: 1
+        };
+
+        const authInfo: AuthInfo = {
+            token: 'test-token',
+            clientId: 'test-client',
+            scopes: ['read', 'write'],
+            expiresAt: Date.now() / 1000 + 3600
+        };
+
+        let receivedMessage: JSONRPCMessage | undefined;
+        let receivedAuthInfo: AuthInfo | undefined;
+        serverTransport.onmessage = (msg, extra) => {
+            receivedMessage = msg;
+            receivedAuthInfo = extra?.authInfo;
+        };
+
+        await clientTransport.send(message, { authInfo });
+        expect(receivedMessage).toEqual(message);
+        expect(receivedAuthInfo).toEqual(authInfo);
+    });
+
+    test('should send message from server to client', async () => {
+        const message: JSONRPCMessage = {
+            jsonrpc: '2.0',
+            method: 'test',
+            id: 1
+        };
+
+        let receivedMessage: JSONRPCMessage | undefined;
+        clientTransport.onmessage = msg => {
+            receivedMessage = msg;
+        };
+
+        await serverTransport.send(message);
+        expect(receivedMessage).toEqual(message);
+    });
+
+    test('should handle close', async () => {
+        let clientClosed = false;
+        let serverClosed = false;
+
+        clientTransport.onclose = () => {
+            clientClosed = true;
+        };
+
+        serverTransport.onclose = () => {
+            serverClosed = true;
+        };
+
+        await clientTransport.close();
+        expect(clientClosed).toBe(true);
+        expect(serverClosed).toBe(true);
+    });
+
+    test('should throw error when sending after close', async () => {
+        await clientTransport.close();
+        await expect(clientTransport.send({ jsonrpc: '2.0', method: 'test', id: 1 })).rejects.toThrow('Not connected');
+    });
+
+    test('should queue messages sent before start', async () => {
+        const message: JSONRPCMessage = {
+            jsonrpc: '2.0',
+            method: 'test',
+            id: 1
+        };
+
+        let receivedMessage: JSONRPCMessage | undefined;
+        serverTransport.onmessage = msg => {
+            receivedMessage = msg;
+        };
+
+        await clientTransport.send(message);
+        await serverTransport.start();
+        expect(receivedMessage).toEqual(message);
+    });
+});