get launch config from settings.json as fallback

Author: eleanorjboyd

src/extension/debugger/configuration/launch.json/launchJsonReader.ts

@@ -5,26 +5,30 @@ import * as path from 'path';
 import * as fs from 'fs-extra';
 import { parse } from 'jsonc-parser';
 import { DebugConfiguration, Uri, WorkspaceFolder } from 'vscode';
-import { getConfiguration, getWorkspaceFolder } from '../../../common/vscodeapi';
+import { getWorkspaceFolder } from '../../../common/vscodeapi';
 import { traceLog } from '../../../common/log/logging';
+import { getConfiguration } from './utils';
 
 export async function getConfigurationsForWorkspace(workspace: WorkspaceFolder): Promise<DebugConfiguration[]> {
     traceLog('Getting configurations for workspace');
     const filename = path.join(workspace.uri.fsPath, '.vscode', 'launch.json');
     if (!(await fs.pathExists(filename))) {
-        // Check launch config in the workspace file
-        const codeWorkspaceConfig = getConfiguration('launch', workspace);
-        if (!codeWorkspaceConfig.configurations || !Array.isArray(codeWorkspaceConfig.configurations)) {
-            return [];
-        }
-        traceLog('Using configuration in workspace');
-        return codeWorkspaceConfig.configurations;
+        return getConfigurationsFromSettings(workspace);
     }
-
     const text = await fs.readFile(filename, 'utf-8');
     const parsed = parse(text, [], { allowTrailingComma: true, disallowComments: false });
-    if (!parsed.configurations || !Array.isArray(parsed.configurations)) {
-        throw Error('Missing field in launch.json: configurations');
+    // no launch.json or no configurations found in launch.json, look in settings.json
+    if (!parsed || !parsed.configurations) {
+        traceLog('No configurations found in launch.json, looking in settings.json.');
+        const settingConfigs = getConfigurationsFromSettings(workspace);
+        if (settingConfigs.length === 0) {
+            throw Error('No configurations found in launch.json or settings.json');
+        }
+        return Promise.resolve(settingConfigs);
+    }
+    // configurations found in launch.json, verify them then return
+    if (!Array.isArray(parsed.configurations) || parsed.configurations.length === 0) {
+        throw Error('Invalid configurations in launch.json');
     }
     if (!parsed.version) {
         throw Error('Missing field in launch.json: version');
@@ -42,3 +46,14 @@ export async function getConfigurationsByUri(uri?: Uri): Promise<DebugConfigurat
     }
     return [];
 }
+
+export function getConfigurationsFromSettings(workspace: WorkspaceFolder): DebugConfiguration[] {
+    // look in settings.json
+    const codeWorkspaceConfig = getConfiguration('launch', workspace);
+    // if this includes user configs, how do I make sure it selects the workspace ones first
+    if (!codeWorkspaceConfig.configurations || !Array.isArray(codeWorkspaceConfig.configurations)) {
+        return [];
+    }
+    traceLog('Using configuration in workspace settings.json.');
+    return codeWorkspaceConfig.configurations;
+}

src/extension/debugger/configuration/launch.json/utils.ts

@@ -0,0 +1,9 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+import { Resource } from '@vscode/python-extension';
+import { WorkspaceConfiguration, workspace } from 'vscode';
+
+export function getConfiguration(section: string, scope?: Resource): WorkspaceConfiguration {
+    return workspace.getConfiguration(section, scope);
+}

src/test/unittest/configuration/launch.json/launchJsonReader.unit.test.ts

@@ -0,0 +1,113 @@
+'use strict';
+
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import * as typemoq from 'typemoq';
+import * as fs from 'fs-extra';
+import { WorkspaceFolder, Uri, WorkspaceConfiguration } from 'vscode';
+import {
+    getConfigurationsForWorkspace,
+    getConfigurationsFromSettings,
+} from '../../../../extension/debugger/configuration/launch.json/launchJsonReader';
+import * as utils from '../../../../extension/debugger/configuration/launch.json/utils';
+
+suite('Debugging - launchJsonReader', () => {
+    let sandbox: sinon.SinonSandbox;
+
+    setup(() => {
+        sandbox = sinon.createSandbox();
+    });
+
+    teardown(() => {
+        sandbox.restore();
+    });
+
+    suite('getConfigurationsForWorkspace', () => {
+        test('Should return configurations from launch.json if it exists', async () => {
+            const workspace = typemoq.Mock.ofType<WorkspaceFolder>();
+            workspace.setup((w) => w.uri).returns(() => Uri.file('/path/to/workspace'));
+
+            const launchJsonContent = `{
+                "version": "0.2.0",
+                "configurations": [
+                    {
+                        "name": "Launch Program",
+                        "type": "python",
+                        "request": "launch",
+                        "program": "${workspace.object.uri}/app.py"
+                    }
+                ]
+            }`;
+
+            sandbox.stub(fs, 'pathExists').resolves(true);
+            sandbox.stub(fs, 'readFile').resolves(launchJsonContent);
+
+            const configurations = await getConfigurationsForWorkspace(workspace.object);
+            assert.strictEqual(configurations.length, 1);
+            assert.strictEqual(configurations[0].name, 'Launch Program');
+        });
+
+        test('Should return configurations from settings.json if launch.json does not exist', async () => {
+            const workspace = typemoq.Mock.ofType<WorkspaceFolder>();
+            workspace.setup((w) => w.uri).returns(() => Uri.file('/path/to/workspace'));
+
+            const mockConfig = typemoq.Mock.ofType<WorkspaceConfiguration>();
+            mockConfig
+                .setup((c) => c.configurations)
+                .returns(() => [
+                    {
+                        name: 'Launch Program 2',
+                        type: 'python',
+                        request: 'launch',
+                        program: '${workspaceFolder}/app.py',
+                    },
+                ]);
+
+            sandbox.stub(fs, 'pathExists').resolves(false);
+            sandbox.stub(utils, 'getConfiguration').returns(mockConfig.object);
+
+            const configurations = await getConfigurationsForWorkspace(workspace.object);
+            assert.strictEqual(configurations.length, 1);
+            assert.strictEqual(configurations[0].name, 'Launch Program 2');
+        });
+    });
+
+    suite('getConfigurationsFromSettings', () => {
+        test('Should return configurations from settings.json', () => {
+            const workspace = typemoq.Mock.ofType<WorkspaceFolder>();
+            workspace.setup((w) => w.uri).returns(() => Uri.file('/path/to/workspace'));
+
+            const mockConfig = typemoq.Mock.ofType<WorkspaceConfiguration>();
+            mockConfig
+                .setup((c) => c.configurations)
+                .returns(() => [
+                    {
+                        name: 'Launch Program 3',
+                        type: 'python',
+                        request: 'launch',
+                        program: '${workspaceFolder}/app.py',
+                    },
+                ]);
+
+            sandbox.stub(utils, 'getConfiguration').returns(mockConfig.object);
+
+            const configurations = getConfigurationsFromSettings(workspace.object);
+            assert.strictEqual(configurations.length, 1);
+            assert.strictEqual(configurations[0].name, 'Launch Program 3');
+        });
+
+        test('Should return empty array if no configurations in settings.json', () => {
+            const workspace = typemoq.Mock.ofType<WorkspaceFolder>();
+            workspace.setup((w) => w.uri).returns(() => Uri.file('/path/to/workspace'));
+
+            const mockConfig = typemoq.Mock.ofType<WorkspaceConfiguration>();
+            mockConfig.setup((c) => c.get('configurations')).returns(() => []);
+            mockConfig.setup((c) => c.configurations).returns(() => []);
+
+            sandbox.stub(utils, 'getConfiguration').returns(mockConfig.object);
+
+            const configurations = getConfigurationsFromSettings(workspace.object);
+            assert.strictEqual(configurations.length, 0);
+        });
+    });
+});