Add debugger test with project Bundler settings

Author: vinistock

test/fixtures/prism

@@ -102,12 +102,24 @@ export class Debugger
     debugConfiguration: vscode.DebugConfiguration,
     _token?: vscode.CancellationToken,
   ): vscode.ProviderResult<vscode.DebugConfiguration> {
-    const workspace = this.workspaceResolver(folder?.uri);
+    // On certain occasions, the objects passed to this method are serialized. In particular for the URI, we have to
+    // ensure we're dealing with a `vscode.Uri` object and not a plain object
+    const uriAttributes =
+      folder?.uri ?? debugConfiguration.workspaceFolder?.uri;
+
+    if (!uriAttributes) {
+      throw new Error(`Couldn't find a workspace to start debugging`);
+    }
+
+    const uri =
+      uriAttributes instanceof vscode.Uri
+        ? uriAttributes
+        : vscode.Uri.from(uriAttributes);
+
+    const workspace = this.workspaceResolver(uri);
 
     if (!workspace) {
-      throw new Error(
-        `Couldn't find a workspace for URI: ${folder?.uri} or editor: ${vscode.window.activeTextEditor}`,
-      );
+      throw new Error(`Couldn't find a workspace for URI: ${uri}`);
     }
 
     if (debugConfiguration.env) {
@@ -120,10 +132,8 @@ export class Debugger
       debugConfiguration.env = workspace.ruby.env;
     }
 
-    const workspaceUri = workspace.workspaceFolder.uri;
-
     debugConfiguration.targetFolder = {
-      path: workspaceUri.fsPath,
+      path: uri.fsPath,
       name: workspace.workspaceFolder.name,
     };
 
@@ -133,7 +143,7 @@ export class Debugger
       return debugConfiguration;
     }
 
-    const customBundleUri = vscode.Uri.joinPath(workspaceUri, ".ruby-lsp");
+    const customBundleUri = vscode.Uri.joinPath(uri, ".ruby-lsp");
 
     return vscode.workspace.fs.readDirectory(customBundleUri).then(
       (value) => {

vscode/src/debugger.ts

@@ -176,6 +176,10 @@ export class RubyLsp {
     }
   }
 
+  getWorkspace(uri: vscode.Uri): Workspace | undefined {
+    return this.workspaces.get(uri.toString());
+  }
+
   private async activateWorkspace(
     workspaceFolder: vscode.WorkspaceFolder,
     eager: boolean,
@@ -693,10 +697,6 @@ export class RubyLsp {
     return this.getWorkspace(workspaceFolder.uri);
   }
 
-  private getWorkspace(uri: vscode.Uri): Workspace | undefined {
-    return this.workspaces.get(uri.toString());
-  }
-
   private workspaceResolver(
     uri: vscode.Uri | undefined,
   ): Workspace | undefined {

vscode/src/rubyLsp.ts

@@ -247,6 +247,7 @@ suite("Debugger", () => {
         name: "Debug",
         request: "launch",
         program: `ruby ${path.join(tmpPath, "test.rb")}`,
+        workspaceFolder,
       });
     } catch (error: any) {
       assert.fail(`Failed to launch debugger: ${error.message}`);

vscode/src/test/suite/debugger.test.ts

@@ -0,0 +1,152 @@
+/* eslint-disable no-process-env */
+import path from "path";
+import assert from "assert";
+import fs from "fs";
+import os from "os";
+
+import sinon from "sinon";
+import * as vscode from "vscode";
+import { beforeEach, afterEach } from "mocha";
+
+import { RubyLsp } from "../../rubyLsp";
+import { RUBY_VERSION } from "../rubyVersion";
+import { ManagerIdentifier } from "../../ruby";
+
+import { FAKE_TELEMETRY } from "./fakeTelemetry";
+
+suite("Ruby LSP", () => {
+  const context = {
+    extensionMode: vscode.ExtensionMode.Test,
+    subscriptions: [],
+    workspaceState: {
+      get: (_name: string) => undefined,
+      update: (_name: string, _value: any) => Promise.resolve(),
+    },
+    extensionUri: vscode.Uri.file(
+      path.dirname(path.dirname(path.dirname(__dirname))),
+    ),
+  } as unknown as vscode.ExtensionContext;
+  let workspacePath: string;
+  let workspaceUri: vscode.Uri;
+  let workspaceFolder: vscode.WorkspaceFolder;
+  const originalSaveBeforeStart = vscode.workspace
+    .getConfiguration("debug")
+    .get("saveBeforeStart");
+  let workspacesStub: sinon.SinonStub;
+
+  beforeEach(async () => {
+    await vscode.workspace
+      .getConfiguration("debug")
+      .update("saveBeforeStart", "none", true);
+    workspacePath = fs.mkdtempSync(
+      path.join(os.tmpdir(), "ruby-lsp-integration-test-"),
+    );
+    workspaceUri = vscode.Uri.file(workspacePath);
+    workspaceFolder = {
+      uri: workspaceUri,
+      name: path.basename(workspacePath),
+      index: 0,
+    };
+
+    workspacesStub = sinon
+      .stub(vscode.workspace, "workspaceFolders")
+      .get(() => [workspaceFolder]);
+  });
+
+  afterEach(async () => {
+    workspacesStub.restore();
+    fs.rmSync(workspacePath, { recursive: true, force: true });
+
+    await vscode.workspace
+      .getConfiguration("debug")
+      .update("saveBeforeStart", originalSaveBeforeStart, true);
+  });
+
+  function writeFileSetup() {
+    fs.writeFileSync(path.join(workspacePath, "test.rb"), "1 + 1");
+    fs.writeFileSync(path.join(workspacePath, ".ruby-version"), RUBY_VERSION);
+    fs.writeFileSync(
+      path.join(workspacePath, "Gemfile"),
+      'source "https://rubygems.org"\n',
+    );
+    fs.writeFileSync(
+      path.join(workspacePath, "Gemfile.lock"),
+      [
+        "GEM",
+        "  remote: https://rubygems.org/",
+        "  specs:",
+        "",
+        "PLATFORMS",
+        "  arm64-darwin-23",
+        "  ruby",
+        "",
+        "DEPENDENCIES",
+        "",
+        "BUNDLED WITH",
+        "  2.5.16",
+      ].join("\n"),
+    );
+    fs.mkdirSync(path.join(workspacePath, ".bundle"));
+    fs.writeFileSync(
+      path.join(workspacePath, ".bundle", "config"),
+      `BUNDLE_PATH: ${path.join("vendor", "bundle")}`,
+    );
+  }
+
+  test("launching debugger in a project with local Bundler settings and composed bundle", async () => {
+    writeFileSetup();
+
+    if (process.env.CI) {
+      await vscode.workspace
+        .getConfiguration("rubyLsp")
+        .update(
+          "rubyVersionManager",
+          { identifier: ManagerIdentifier.None },
+          true,
+        );
+    }
+
+    const rubyLsp = new RubyLsp(context, FAKE_TELEMETRY);
+
+    try {
+      await rubyLsp.activate();
+    } catch (error: any) {
+      assert.fail(
+        `Failed to activate Ruby LSP: ${error.message}\n\n${error.stack}`,
+      );
+    }
+
+    // Verify that the composed environment was properly merged into the Ruby object
+    const workspace = rubyLsp.getWorkspace(workspaceFolder.uri)!;
+    assert.match(workspace.ruby.env.BUNDLE_PATH!, /vendor(\/|\\)bundle/);
+    assert.match(
+      workspace.ruby.env.BUNDLE_GEMFILE!,
+      /\.ruby-lsp(\/|\\)Gemfile/,
+    );
+
+    try {
+      await vscode.debug.startDebugging(workspaceFolder, {
+        type: "ruby_lsp",
+        name: "Debug",
+        request: "launch",
+        program: `ruby ${path.join(workspacePath, "test.rb")}`,
+        workspaceFolder,
+      });
+    } catch (error: any) {
+      assert.fail(`Failed to launch debugger: ${error.message}`);
+    }
+
+    await new Promise<void>((resolve) => {
+      const callback = vscode.debug.onDidTerminateDebugSession((_session) => {
+        context.subscriptions.forEach((subscription) => {
+          if (!("logLevel" in subscription)) {
+            subscription.dispose();
+          }
+        });
+
+        callback.dispose();
+        resolve();
+      });
+    });
+  }).timeout(90000);
+});

vscode/src/test/suite/rubyLsp.test.ts

@@ -2,6 +2,7 @@ import * as assert from "assert";
 
 import * as vscode from "vscode";
 import { CodeLens } from "vscode-languageclient/node";
+import { afterEach } from "mocha";
 
 import { TestController } from "../../testController";
 import { Command } from "../../common";
@@ -18,6 +19,10 @@ suite("TestController", () => {
     },
   } as unknown as vscode.ExtensionContext;
 
+  afterEach(() => {
+    context.subscriptions.forEach((subscription) => subscription.dispose());
+  });
+
   test("createTestItems doesn't break when there's a missing group", () => {
     const controller = new TestController(
       context,