add test

Author: eleanorjboyd

.vscode/launch.json

@@ -31,12 +31,15 @@
 			"args": [
 				"./out/test/**/*.unit.test.js",
 				"--extensionDevelopmentPath=${workspaceFolder}",
-				"--extensionTestsPath=${workspaceFolder}/out/test/unittest/index"
+				"--extensionTestsPath=${workspaceFolder}/out/test/unittest/index",
+				//"--grep",
+				//"this test suite"
 			],
 			"outFiles": [
 				"${workspaceFolder}/out/**/*.js",
 			],
-			"preLaunchTask": "tasks: watch-tests"
+			"preLaunchTask": "tasks: watch-tests",
+			"timeout": 600000 // Increase timeout to 10 minutes (600000 ms)
 		},
 	]
 }

src/extension/noConfigDebugInit.ts

@@ -1,7 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { IExtensionContext } from './common/types';
-import { DebugSessionOptions, debug, RelativePattern, workspace } from 'vscode';
+import { DebugSessionOptions, debug, RelativePattern } from 'vscode';
+import { createFileSystemWatcher } from './utils';
 
 /**
  * Registers the configuration-less debugging setup for the extension.
@@ -32,19 +33,19 @@ export async function registerConfiglessDebug(context: IExtensionContext): Promi
 
     // create file system watcher for the debuggerAdapterEndpointFolder for when the communication port is written
     context.subscriptions.push(
-        workspace.createFileSystemWatcher(new RelativePattern(debugAdapterEndpointDir, '**/*')).onDidCreate((uri) => {
-            console.log(`File created: ${uri.fsPath}`);
+        createFileSystemWatcher(new RelativePattern(debugAdapterEndpointDir, '**/*')).onDidCreate((uri) => {
+            // console.log(`File created: ${uri.fsPath}`);
             const filePath = uri.fsPath;
             fs.readFile(filePath, 'utf8', (err, data) => {
                 if (err) {
-                    console.error(`Error reading file: ${err}`);
+                    // console.error(`Error reading file: ${err}`);
                     return;
                 }
                 try {
                     // parse the client port
                     const jsonData = JSON.parse(data);
                     const clientPort = jsonData.client?.port;
-                    console.log(`Client port: ${clientPort}`);
+                    //console.log(`Client port: ${clientPort}`);
 
                     const options: DebugSessionOptions = {
                         noDebug: false,
@@ -66,17 +67,18 @@ export async function registerConfiglessDebug(context: IExtensionContext): Promi
                         .then(
                             (started) => {
                                 if (started) {
-                                    console.log('Debug session started successfully');
+                                    //console.log('Debug session started successfully');
                                 } else {
-                                    console.error('Failed to start debug session');
+                                    //console.error('Failed to start debug session');
                                 }
                             },
                             (error) => {
-                                console.error(`Error starting debug session: ${error}`);
+                                //console.error(`Error starting debug session: ${error}`);
+                                error;
                             },
                         );
                 } catch (parseErr) {
-                    console.error(`Error parsing JSON: ${parseErr}`);
+                    //console.error(`Error parsing JSON: ${parseErr}`);
                 }
             });
             JSON.parse;

src/extension/utils.ts

@@ -0,0 +1,5 @@
+import { workspace } from 'vscode';
+
+export function createFileSystemWatcher(args: any) {
+    return workspace.createFileSystemWatcher(args);
+}

src/test/unittest/noConfigDebugInit.unit.test.ts

@@ -0,0 +1,79 @@
+import * as path from 'path';
+import { IExtensionContext } from '../../extension/common/types';
+import { registerConfiglessDebug } from '../../extension/noConfigDebugInit';
+import * as TypeMoq from 'typemoq';
+import * as sinon from 'sinon';
+import { Uri } from 'vscode';
+import * as utils from '../../extension/utils';
+import { assert } from 'console';
+import * as fs from 'fs';
+
+suite('registerConfiglessDebug', function () {
+    this.timeout(100000); // Increase timeout to 10 seconds
+    let replaceStub: sinon.SinonStub;
+    let appendStub: sinon.SinonStub;
+    let context: TypeMoq.IMock<IExtensionContext>;
+    let createFileSystemWatcher: sinon.SinonStub;
+
+    setup(() => {
+        context = TypeMoq.Mock.ofType<IExtensionContext>();
+
+        context.setup((c) => c.storageUri).returns(() => Uri.parse('a'));
+        context.setup((c) => (c as any).extensionPath).returns(() => 'b');
+        context.setup((c) => c.subscriptions).returns(() => []);
+
+        createFileSystemWatcher = sinon.stub(utils, 'createFileSystemWatcher');
+        createFileSystemWatcher.callsFake(() => {
+            return {
+                onDidCreate: (cb: (arg0: Uri) => void) => {
+                    cb(Uri.parse('a'));
+                },
+            };
+        });
+        sinon.stub(fs, 'readFile').callsFake(
+            (TypeMoq.It.isAny(),
+            TypeMoq.It.isAny(),
+            (err, data) => {
+                console.log(err, data);
+            }),
+        );
+    });
+    teardown(() => {
+        sinon.restore();
+    });
+
+    test('should add environment variables for DEBUGPY_ADAPTER_ENDPOINTS, BUNDLED_DEBUGPY_PATH, and PATH', async () => {
+        const debugAdapterEndpointDir = path.join(context.object.extensionPath, 'noConfigDebugAdapterEndpoints');
+        const debuggerAdapterEndpointPath = path.join(debugAdapterEndpointDir, 'debuggerAdapterEndpoint.txt');
+        const noConfigScriptsDir = path.join(context.object.extensionPath, 'bundled/scripts/noConfigScripts');
+        const bundledDebugPath = path.join(context.object.extensionPath, 'bundled/libs/debugpy');
+
+        const environmentVariableCollectionMock = TypeMoq.Mock.ofType<any>();
+        replaceStub = sinon.stub();
+        appendStub = sinon.stub();
+        environmentVariableCollectionMock
+            .setup((x) => x.replace(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .callback((key, value) => {
+                if (key === 'DEBUGPY_ADAPTER_ENDPOINTS') {
+                    assert(value === debuggerAdapterEndpointPath);
+                } else if (key === 'BUNDLED_DEBUGPY_PATH') {
+                    assert(value === bundledDebugPath);
+                }
+            })
+            .returns(replaceStub);
+        environmentVariableCollectionMock
+            .setup((x) => x.append(TypeMoq.It.isAny(), TypeMoq.It.isAny()))
+            .callback((key, value) => {
+                if (key === 'PATH') {
+                    assert(value === `:${noConfigScriptsDir}`);
+                }
+            })
+            .returns(appendStub);
+
+        context.setup((c) => c.environmentVariableCollection).returns(() => environmentVariableCollectionMock.object);
+
+        await registerConfiglessDebug(context.object);
+        console.log('All done!');
+        sinon.assert.calledTwice(replaceStub);
+    });
+});