refactor

Author: Hweinstock

packages/core/src/test/shared/utilities/pathFind.test.ts

@@ -47,7 +47,7 @@ describe('pathFind', function () {
             const workspace = await testutil.createTestWorkspaceFolder()
             const fakeSshPath = path.join(workspace.uri.fsPath, `ssh${isWin() ? '.cmd' : ''}`)
 
-            await testutil.withEnvPath(workspace.uri.fsPath, async () => {
+            await testutil.withEnv(testutil.envWithNewPath(workspace.uri.fsPath), async () => {
                 const firstResult = await findSshPath(false)
 
                 await testutil.createExecutableFile(fakeSshPath, 'echo "this is ssh"')
@@ -64,7 +64,7 @@ describe('pathFind', function () {
             const fakeSshPath = path.join(workspace.uri.fsPath, `ssh${isWin() ? '.cmd' : ''}`)
             await fs.writeFile(fakeSshPath, 'this is not executable')
 
-            await testutil.withEnvPath(workspace.uri.fsPath, async () => {
+            await testutil.withEnv(testutil.envWithNewPath(workspace.uri.fsPath), async () => {
                 const firstResult = await findSshPath(false)
                 assert.notStrictEqual(firstResult, 'ssh')
             })
@@ -75,7 +75,7 @@ describe('pathFind', function () {
             const fakeSshPath = path.join(workspace.uri.fsPath, `ssh${isWin() ? '.cmd' : ''}`)
             await testutil.createExecutableFile(fakeSshPath, 'echo "this is ssh"')
 
-            await testutil.withEnvPath(workspace.uri.fsPath, async () => {
+            await testutil.withEnv(testutil.envWithNewPath(workspace.uri.fsPath), async () => {
                 const firstResult = await findSshPath(true)
 
                 await fs.delete(fakeSshPath)

packages/core/src/test/shared/utilities/testUtil.test.ts

@@ -3,26 +3,26 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import assert from 'assert'
-import { createTestWorkspaceFolder, readEnvPath, withEnvPath } from '../../testUtil'
+import { createTestWorkspaceFolder, envWithNewPath, readEnv, withEnv } from '../../testUtil'
 
-describe('withEnvPath', function () {
+describe('withEnv', function () {
     it('resets path when error in task', async function () {
-        const originalPath = readEnvPath()
+        const originalEnv = readEnv()
         const tempFolder = await createTestWorkspaceFolder()
         try {
-            await withEnvPath(tempFolder.uri.fsPath, async () => {
+            await withEnv(envWithNewPath(tempFolder.uri.fsPath), async () => {
                 throw new Error()
             })
         } catch {}
-        assert.strictEqual(readEnvPath(), originalPath)
+        assert.strictEqual(readEnv().PATH, originalEnv.PATH)
     })
 
     it('changes $PATH temporarily', async function () {
-        const originalPath = readEnvPath()
+        const originalEnv = readEnv()
         const tempFolder = await createTestWorkspaceFolder()
-        await withEnvPath(tempFolder.uri.fsPath, async () => {
-            assert.strictEqual(readEnvPath(), tempFolder.uri.fsPath)
+        await withEnv(envWithNewPath(tempFolder.uri.fsPath), async () => {
+            assert.strictEqual(readEnv().PATH, tempFolder.uri.fsPath)
         })
-        assert.strictEqual(readEnvPath(), originalPath)
+        assert.strictEqual(readEnv().PATH, originalEnv.PATH)
     })
 })

packages/core/src/test/testUtil.ts

@@ -615,24 +615,28 @@ export function getFetchStubWithResponse(response: Partial<Response>) {
     return stub(request, 'fetch').returns({ response: new Promise((res, _) => res(response)) } as any)
 }
 
-export function setEnvPath(newPath: string): void {
-    process.env.PATH = newPath
+export function setEnv(newEnv: NodeJS.ProcessEnv): void {
+    process.env = newEnv
 }
 
-export function readEnvPath(): string {
-    return process.env.PATH || ''
+export function readEnv(): NodeJS.ProcessEnv {
+    return process.env
 }
 /**
  * Overwrite the $PATH environment variable for the span of the provided task, then reset it.
  * @param newPath temporary $PATH value
  * @param task work to be done with $PATH set.
  */
-export async function withEnvPath(newPath: string, task: () => Promise<void>): Promise<void | never> {
-    const originalPath = readEnvPath()
-    setEnvPath(newPath)
+export async function withEnv(newEnv: NodeJS.ProcessEnv, task: () => Promise<void>): Promise<void | never> {
+    const originalEnv = readEnv()
+    setEnv(newEnv)
     try {
         await task()
     } finally {
-        setEnvPath(originalPath)
+        setEnv(originalEnv)
     }
 }
+
+export function envWithNewPath(newPath: string): NodeJS.ProcessEnv {
+    return { ...process.env, PATH: newPath }
+}