Get a clean environment to run bricks (#240)

Bricks can pickup auth creds from environment variables. We need to get
a clean environment to run bricks commands in.

Author: kartikgupta-db

packages/databricks-vscode/src/cli/BricksTasks.test.ts

@@ -1,24 +1,68 @@
 import * as assert from "assert";
-import {instance, mock} from "ts-mockito";
+import {instance, mock, when} from "ts-mockito";
+import {Uri} from "vscode";
 import type {ConnectionManager} from "../configuration/ConnectionManager";
-import {SyncTask} from "./BricksTasks";
+import {DatabricksWorkspace} from "../configuration/DatabricksWorkspace";
+import {SyncDestination} from "../configuration/SyncDestination";
+import {LazyCustomSyncTerminal, SyncTask} from "./BricksTasks";
 import type {CliWrapper} from "./CliWrapper";
 
 describe(__filename, () => {
     let connection: ConnectionManager;
     let cli: CliWrapper;
 
     beforeEach(() => {
-        connection = instance(mock<ConnectionManager>());
-        cli = instance(mock<CliWrapper>());
+        connection = mock<ConnectionManager>();
+        cli = mock<CliWrapper>();
     });
 
     it("should create a sync task", () => {
-        const task = new SyncTask(connection, cli, "incremental", () => {});
+        const task = new SyncTask(
+            instance(connection),
+            instance(cli),
+            "incremental",
+            () => {}
+        );
 
         assert.equal(task.definition.type, "databricks");
         assert.equal(task.definition.task, "sync");
         assert.equal(task.isBackground, true);
         assert.deepEqual(task.problemMatchers, ["$bricks-sync"]);
     });
+
+    it("should create pseudo terminal with correct environment variables", () => {
+        const mockDbWorkspace = mock(DatabricksWorkspace);
+        when(mockDbWorkspace.profile).thenReturn("profile");
+
+        const mockSyncDestination = mock(SyncDestination);
+        when(mockSyncDestination.vscodeWorkspacePath).thenReturn(
+            Uri.file("/path/to/local/workspace")
+        );
+
+        when(connection.databricksWorkspace).thenReturn(
+            instance(mockDbWorkspace)
+        );
+        when(connection.syncDestination).thenReturn(
+            instance(mockSyncDestination)
+        );
+
+        const terminal = new LazyCustomSyncTerminal(
+            instance(connection),
+            instance(cli),
+            "full",
+            () => {}
+        );
+
+        assert.deepEqual(terminal.getProcessOptions(), {
+            cwd: "/path/to/local/workspace",
+            env: {
+                /* eslint-disable @typescript-eslint/naming-convention */
+                BRICKS_ROOT: "/path/to/local/workspace",
+                DATABRICKS_CONFIG_PROFILE: "profile",
+                HOME: process.env.HOME,
+                PATH: process.env.PATH,
+                /* eslint-enable @typescript-eslint/naming-convention */
+            },
+        });
+    });
 });

packages/databricks-vscode/src/cli/BricksTasks.ts

@@ -6,7 +6,6 @@ import {
     TaskRevealKind,
     TaskScope,
     window,
-    workspace,
     Event,
     EventEmitter,
 } from "vscode";
@@ -96,7 +95,7 @@ class CustomSyncTerminal implements Pseudoterminal {
 
     private startSyncProcess() {
         this.syncProcess = spawn(this.cmd, this.args, {
-            env: {...process.env, ...this.options.env},
+            env: this.options?.env,
             cwd: this.options?.cwd,
         });
 
@@ -158,7 +157,7 @@ class CustomSyncTerminal implements Pseudoterminal {
  * vscode task, which allows us to parse the stdout/stderr bricks sync logs and compute
  * sync completeness state based on the output logs
  */
-class LazyCustomSyncTerminal extends CustomSyncTerminal {
+export class LazyCustomSyncTerminal extends CustomSyncTerminal {
     private command?: Command;
     private killThis = false;
 
@@ -183,41 +182,44 @@ class LazyCustomSyncTerminal extends CustomSyncTerminal {
                 },
             },
             options: {
-                get(): SpawnOptions {
-                    const workspacePath = workspace.rootPath;
-                    if (!workspacePath) {
-                        window.showErrorMessage(
-                            "Can't start sync: No workspace opened!"
-                        );
-                        throw new Error(
-                            "Can't start sync: No workspace opened!"
-                        );
-                    }
-
-                    const dbWorkspace = this.connection.databricksWorkspace;
-                    if (!dbWorkspace) {
-                        window.showErrorMessage(
-                            "Can't start sync: Databricks connection not configured!"
-                        );
-                        throw new Error(
-                            "Can't start sync: Databricks connection not configured!"
-                        );
-                    }
-
-                    return {
-                        cwd: workspacePath,
-                        env: {
-                            /* eslint-disable @typescript-eslint/naming-convention */
-                            BRICKS_ROOT: workspacePath,
-                            DATABRICKS_CONFIG_PROFILE: dbWorkspace.profile,
-                            /* eslint-enable @typescript-eslint/naming-convention */
-                        },
-                    };
+                get: () => {
+                    return this.getProcessOptions();
                 },
             },
         });
     }
 
+    getProcessOptions(): SpawnOptions {
+        const workspacePath =
+            this.connection.syncDestination?.vscodeWorkspacePath.fsPath;
+        if (!workspacePath) {
+            window.showErrorMessage("Can't start sync: No workspace opened!");
+            throw new Error("Can't start sync: No workspace opened!");
+        }
+
+        const dbWorkspace = this.connection.databricksWorkspace;
+        if (!dbWorkspace) {
+            window.showErrorMessage(
+                "Can't start sync: Databricks connection not configured!"
+            );
+            throw new Error(
+                "Can't start sync: Databricks connection not configured!"
+            );
+        }
+
+        return {
+            cwd: workspacePath,
+            env: {
+                /* eslint-disable @typescript-eslint/naming-convention */
+                BRICKS_ROOT: workspacePath,
+                DATABRICKS_CONFIG_PROFILE: dbWorkspace.profile,
+                HOME: process.env.HOME,
+                PATH: process.env.PATH,
+                /* eslint-enable @typescript-eslint/naming-convention */
+            },
+        } as SpawnOptions;
+    }
+
     getSyncCommand(): Command {
         if (
             this.connection.state !== "CONNECTED" &&