Enable debugger attach test (microsoft#873)

Fix microsoft#598

Author: DonJayamanne

src/test/debugger/attach.test.ts

@@ -1,35 +1,27 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-import { expect, use } from 'chai';
-import * as chaiAsPromised from 'chai-as-promised';
+import { expect } from 'chai';
 import { ChildProcess } from 'child_process';
 import * as getFreePort from 'get-port';
-import { EOL } from 'os';
 import * as path from 'path';
-import { ThreadEvent } from 'vscode-debugadapter';
 import { DebugClient } from 'vscode-debugadapter-testsupport';
 import { createDeferred } from '../../client/common/helpers';
 import { BufferDecoder } from '../../client/common/process/decoder';
 import { ProcessService } from '../../client/common/process/proc';
 import { AttachRequestArguments } from '../../client/debugger/Common/Contracts';
 import { initialize } from '../initialize';
 
-use(chaiAsPromised);
+// tslint:disable:max-func-body-length no-empty
 
 const fileToDebug = path.join(__dirname, '..', '..', '..', 'src', 'testMultiRootWkspc', 'workspace5', 'remoteDebugger.py');
 const ptvsdPath = path.join(__dirname, '..', '..', '..', 'pythonFiles', 'PythonTools');
 const DEBUG_ADAPTER = path.join(__dirname, '..', '..', 'client', 'debugger', 'Main.js');
 
-// tslint:disable-next-line:max-func-body-length
 suite('Attach Debugger', () => {
     let debugClient: DebugClient;
     let procToKill: ChildProcess;
-    suiteSetup(function () {
-        // tslint:disable-next-line:no-invalid-this
-        this.skip();
-        return initialize();
-    });
+    suiteSetup(initialize);
 
     setup(async () => {
         await new Promise(resolve => setTimeout(resolve, 1000));
@@ -40,11 +32,12 @@ suite('Attach Debugger', () => {
         // Wait for a second before starting another test (sometimes, sockets take a while to get closed).
         await new Promise(resolve => setTimeout(resolve, 1000));
         try {
-            debugClient.stop();
-            // tslint:disable-next-line:no-empty
+            await debugClient.stop().catch(() => { });
         } catch (ex) { }
         if (procToKill) {
-            procToKill.kill();
+            try {
+                procToKill.kill();
+            } catch { }
         }
     });
     test('Confirm we are able to attach to a running program', async () => {
@@ -66,35 +59,23 @@ suite('Attach Debugger', () => {
         const result = procService.execObservable('python', [fileToDebug, port.toString()], { env: customEnv, cwd: path.dirname(fileToDebug) });
         procToKill = result.proc;
 
-        const completed = createDeferred();
         const expectedOutputs = [
             { value: 'start', deferred: createDeferred() },
-            { value: 'Peter Smith', deferred: createDeferred() },
+            { value: 'attached', deferred: createDeferred() },
             { value: 'end', deferred: createDeferred() }
         ];
         const startOutputReceived = expectedOutputs[0].deferred.promise;
-        const firstOutputReceived = expectedOutputs[1].deferred.promise;
-        const secondOutputReceived = expectedOutputs[2].deferred.promise;
+        const attachedOutputReceived = expectedOutputs[1].deferred.promise;
+        const lastOutputReceived = expectedOutputs[2].deferred.promise;
 
         result.out.subscribe(output => {
             if (expectedOutputs[0].value === output.out) {
                 expectedOutputs.shift()!.deferred.resolve();
             }
-        }, ex => {
-            completed.reject(ex);
-        }, () => {
-            completed.resolve();
         });
 
         await startOutputReceived;
 
-        const threadIdPromise = createDeferred<number>();
-        debugClient.on('thread', (data: ThreadEvent) => {
-            if (data.body.reason === 'started') {
-                threadIdPromise.resolve(data.body.threadId);
-            }
-        });
-
         const initializePromise = debugClient.initializeRequest({
             adapterID: 'python',
             linesStartAt1: true,
@@ -105,21 +86,28 @@ suite('Attach Debugger', () => {
         await debugClient.attachRequest(args);
         await initializePromise;
 
-        // Wait till we get the thread of the program.
-        const threadId = await threadIdPromise.promise;
-        expect(threadId).to.be.greaterThan(0, 'ThreadId not received');
+        // Wait till we attach.
+        await attachedOutputReceived;
 
-        // Continue the program.
-        await debugClient.continueRequest({ threadId });
+        // Add a breakpoint.
+        const breakpointLocation = { path: fileToDebug, column: 0, line: 16 };
+        await debugClient.setBreakpointsRequest({
+            lines: [breakpointLocation.line],
+            breakpoints: [{ line: breakpointLocation.line, column: breakpointLocation.column }],
+            source: { path: breakpointLocation.path }
+        });
 
-        // Value for input prompt.
-        result.proc.stdin.write(`Peter Smith${EOL}`);
-        await firstOutputReceived;
+        await debugClient.assertStoppedLocation('breakpoint', breakpointLocation);
 
-        result.proc.stdin.write(`${EOL}`);
-        await secondOutputReceived;
-        await completed.promise;
+        // Get thread to continue.
+        const threads = await debugClient.threadsRequest();
+        expect(threads).to.be.not.equal(undefined, 'no threads response');
+        expect(threads.body.threads).to.be.lengthOf(1);
+
+        // Continue the program.
+        await debugClient.continueRequest({ threadId: threads.body.threads[0].id });
 
+        await lastOutputReceived;
         await debugClient.waitForEvent('terminated');
     });
 });

src/testMultiRootWkspc/workspace5/remoteDebugger.py

@@ -4,13 +4,14 @@
 
 sys.stdout.write('start')
 sys.stdout.flush()
-address = ('0.0.0.0', int(sys.argv[1]))
+address = ('127.0.0.1', int(sys.argv[1]))
 ptvsd.enable_attach('super_secret', address)
 ptvsd.wait_for_attach()
 
-name = input()
-sys.stdout.write(name)
+sys.stdout.write('attached')
 sys.stdout.flush()
-input()
+# Give the debugger some time to add a breakpoint.
+time.sleep(2)
+
 sys.stdout.write('end')
 sys.stdout.flush()