ipc tests

src/vs/base/parts/ipc/test/node/ipc.test.ts

@@ -6,8 +6,10 @@
 'use strict';
 
 import * as assert from 'assert';
-import { IMessagePassingProtocol } from 'vs/base/parts/ipc/node/ipc';
-import { Emitter, toNativePromise } from 'vs/base/common/event';
+import { IMessagePassingProtocol, IPCServer, ClientConnectionEvent, IPCClient, IChannel } from 'vs/base/parts/ipc/node/ipc';
+import { Emitter, toNativePromise, Event } from 'vs/base/common/event';
+import { TPromise } from 'vs/base/common/winjs.base';
+import { CancellationToken } from 'vs/base/common/cancellation';
 
 class QueueProtocol implements IMessagePassingProtocol {
 
@@ -53,7 +55,102 @@ function createProtocolPair(): [IMessagePassingProtocol, IMessagePassingProtocol
 	return [one, other];
 }
 
-suite('IPC', function () {
+class TestIPCClient extends IPCClient {
+
+	private _onDidDisconnect = new Emitter<void>();
+	readonly onDidDisconnect = this._onDidDisconnect.event;
+
+	constructor(protocol: IMessagePassingProtocol, id: string) {
+		super(protocol, id);
+	}
+
+	dispose(): void {
+		this._onDidDisconnect.fire();
+		super.dispose();
+	}
+}
+
+class TestIPCServer extends IPCServer {
+
+	private onDidClientConnect: Emitter<ClientConnectionEvent>;
+
+	constructor() {
+		const onDidClientConnect = new Emitter<ClientConnectionEvent>();
+		super(onDidClientConnect.event);
+		this.onDidClientConnect = onDidClientConnect;
+	}
+
+	createConnection(id: string): IPCClient {
+		const [pc, ps] = createProtocolPair();
+		const client = new TestIPCClient(pc, id);
+
+		this.onDidClientConnect.fire({
+			protocol: ps,
+			onDidClientDisconnect: client.onDidDisconnect
+		});
+
+		return client;
+	}
+}
+
+const TestChannelId = 'testchannel';
+
+interface ITestService {
+	marco(): TPromise<string>;
+	error(message: string): TPromise<void>;
+}
+
+class TestService implements ITestService {
+
+	marco(): TPromise<string> {
+		return TPromise.wrap('polo');
+	}
+
+	error(message: string): TPromise<void> {
+		return TPromise.wrapError(new Error(message));
+	}
+}
+
+interface ITestChannel extends IChannel {
+	call(command: 'marco'): TPromise<string>;
+	call(command: 'error'): TPromise<void>;
+	call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): TPromise<T>;
+	listen<T>(event: string, arg?: any): Event<T>;
+}
+
+class TestChannel implements ITestChannel {
+
+	constructor(private service: TestService) { }
+
+	call(command: string, arg?: any, cancellationToken?: CancellationToken): TPromise<any> {
+		switch (command) {
+			case 'marco': return this.service.marco();
+			case 'error': return this.service.error(arg);
+			default: return TPromise.wrapError(new Error('not implemented'));
+		}
+	}
+
+	listen<T>(event: string, arg?: any): Event<T> {
+		switch (event) {
+			default: throw new Error('not implemented');
+		}
+	}
+}
+
+class TestChannelClient implements ITestService {
+
+	constructor(private channel: ITestChannel) { }
+
+	marco(): TPromise<string> {
+		return this.channel.call('marco');
+	}
+
+	error(message: string): TPromise<void> {
+		return this.channel.call('error', message);
+	}
+}
+
+suite('Base IPC', function () {
 
 	test('createProtocolPair', async function () {
 		const [clientProtocol, serverProtocol] = createProtocolPair();
@@ -71,6 +168,27 @@ suite('IPC', function () {
 		assert.strictEqual(b3, b4);
 	});
 
+	test('call', async function () {
+		const service = new TestService();
+		const server = new TestIPCServer();
+		server.registerChannel(TestChannelId, new TestChannel(service));
+
+		const client = server.createConnection('client1');
+		const ipcService = new TestChannelClient(client.getChannel(TestChannelId));
+
+		assert.equal(await ipcService.marco(), 'polo');
+
+		try {
+			await ipcService.error('nice error');
+			assert.fail('should not reach here');
+		} catch (err) {
+			assert.equal(err.message, 'nice error');
+		}
+
+		client.dispose();
+		server.dispose();
+	});
+
 	suite('getDelayedChannel', function () {
 
 	});