Adapt to latest -core change

package.json

@@ -30,6 +30,7 @@
     "@types/mockery": "^1.4.29",
     "@types/node": "^6.0.41",
     "@types/source-map": "^0.1.27",
+    "chrome-remote-debug-protocol": "^1.2.20161007",
     "gulp": "^3.9.1",
     "mocha": "^3.0.2",
     "mockery": "^1.7.0",

test/chromeDebugAdapter.test.ts

@@ -10,6 +10,7 @@ import {EventEmitter} from 'events';
 import * as assert from 'assert';
 import {Mock, MockBehavior, It} from 'typemoq';
 
+import {getMockChromeConnectionApi, IMockChromeConnectionAPI} from './debugProtocolMocks';
 import * as testUtils from './testUtils';
 
 /** Not mocked - use for type only */
@@ -27,6 +28,7 @@ const MODULE_UNDER_TEST = '../src/chromeDebugAdapter';
 suite('ChromeDebugAdapter', () => {
     let mockChromeConnection: Mock<ChromeConnection>;
     let mockEventEmitter: EventEmitter;
+    let mockChrome: IMockChromeConnectionAPI;
 
     let chromeDebugAdapter: _ChromeDebugAdapter;
 
@@ -35,17 +37,21 @@ suite('ChromeDebugAdapter', () => {
         mockery.enable({ useCleanCache: true, warnOnReplace: false, warnOnUnregistered: false });
 
         // Create a ChromeConnection mock with .on and .attach. Tests can fire events via mockEventEmitter
-        mockEventEmitter = new EventEmitter();
         mockChromeConnection = Mock.ofType(ChromeConnection, MockBehavior.Strict);
+        mockChrome = getMockChromeConnectionApi();
+        mockEventEmitter = mockChrome.mockEventEmitter;
         mockChromeConnection
-            .setup(x => x.on(It.isAnyString(), It.isAny()))
-            .callback((eventName: string, handler: (msg: any) => void) => mockEventEmitter.on(eventName, handler));
+            .setup(x => x.api)
+            .returns(() => mockChrome.apiObjects);
         mockChromeConnection
             .setup(x => x.attach(It.isValue(undefined), It.isAnyNumber(), It.isValue(undefined)))
             .returns(() => Promise.resolve());
         mockChromeConnection
             .setup(x => x.isAttached)
             .returns(() => false);
+        mockChromeConnection
+            .setup(x => x.run())
+            .returns(() => Promise.resolve());
 
         // Instantiate the ChromeDebugAdapter, injecting the mock ChromeConnection
         const cDAClass: typeof _ChromeDebugAdapter = require(MODULE_UNDER_TEST).ChromeDebugAdapter;

test/debugProtocolMocks.ts

@@ -0,0 +1,86 @@
+/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------*/
+/* tslint:disable:typedef */
+// Copied from -core because I don't want to include test stuff in the npm package
+
+import {EventEmitter} from 'events';
+import {Mock} from 'typemoq';
+import Crdp from 'chrome-remote-debug-protocol';
+
+export interface IMockChromeConnectionAPI {
+    apiObjects: Crdp.CrdpClient;
+
+    Debugger: Mock<Crdp.DebuggerClient>;
+    Runtime: Mock<Crdp.RuntimeClient>;
+    Inspector: Mock<Crdp.InspectorClient>;
+
+    mockEventEmitter: EventEmitter;
+}
+
+// See https://github.com/florinn/typemoq/issues/20
+function getDebuggerStubs(mockEventEmitter) {
+    return {
+        setBreakpoint() { },
+        setBreakpointByUrl() { },
+        removeBreakpoint() { },
+        enable() { },
+        evaluateOnCallFrame() { },
+
+        onPaused(handler) { mockEventEmitter.on('Debugger.paused', handler); },
+        onResumed(handler) { mockEventEmitter.on('Debugger.resumed', handler); },
+        onScriptParsed(handler) { mockEventEmitter.on('Debugger.scriptParsed', handler); },
+        onBreakpointResolved(handler) { mockEventEmitter.on('Debugger.breakpointResolved', handler); },
+    };
+}
+
+function getRuntimeStubs(mockEventEmitter) {
+    return {
+        enable() { },
+        evaluate() { },
+
+        onConsoleAPICalled(handler) { mockEventEmitter.on('Runtime.consoleAPICalled', handler); },
+        onExecutionContextsCleared(handler) { mockEventEmitter.on('Runtime.executionContextsCleared', handler); }
+    };
+}
+
+function getInspectorStubs(mockEventEmitter) {
+    return {
+        onDetached(handler) { mockEventEmitter.on('Inspector.detach', handler); }
+    };
+}
+
+export function getMockChromeConnectionApi(): IMockChromeConnectionAPI {
+    const mockEventEmitter = new EventEmitter();
+
+    let mockDebugger = Mock.ofInstance<Crdp.DebuggerClient>(<any>getDebuggerStubs(mockEventEmitter));
+    mockDebugger.callBase = true;
+    mockDebugger
+        .setup(x => x.enable())
+        .returns(() => Promise.resolve());
+
+    let mockRuntime = Mock.ofInstance<Crdp.RuntimeClient>(<any>getRuntimeStubs(mockEventEmitter));
+    mockRuntime.callBase = true;
+    mockRuntime
+        .setup(x => x.enable())
+        .returns(() => Promise.resolve());
+
+    let mockInspector = Mock.ofInstance<Crdp.InspectorClient>(<any>getInspectorStubs(mockEventEmitter));
+    mockInspector.callBase = true;
+
+    const chromeConnectionAPI: Crdp.CrdpClient = <any>{
+        Debugger: mockDebugger.object,
+        Runtime: mockRuntime.object,
+        Inspector: mockInspector.object
+    };
+
+    return {
+        apiObjects: chromeConnectionAPI,
+
+        Debugger: mockDebugger,
+        Runtime: mockRuntime,
+        Inspector: mockInspector,
+
+        mockEventEmitter
+    };
+}

tslint.json

@@ -60,7 +60,7 @@
     "no-use-before-declare": true,
     "no-var-keyword": true,
     "no-var-requires": true,
-    "object-literal-sort-keys": true,
+    "object-literal-sort-keys": false,
     "one-line": [
       true,
       "check-open-brace",
@@ -73,10 +73,9 @@
       "single"
     ],
     "radix": true,
-    "semicolon": true,
     "switch-default": true,
     "trailing-comma": [
-      true,
+      false,
       {
         "multiline": "always",
         "singleline": "never"