write tests that do not stub fs

Author: Hweinstock

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

@@ -106,7 +106,7 @@ export async function findSshPath(useCache: boolean = true): Promise<string | un
             continue
         }
         if (await tryRun(p, ['-G', 'x'], 'noresult' /* "ssh -G" prints quasi-sensitive info. */)) {
-            sshPath = p
+            sshPath = useCache ? p : sshPath
             return p
         }
     }

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

@@ -9,7 +9,7 @@ import * as os from 'os'
 import * as path from 'path'
 import * as testutil from '../../testUtil'
 import { fs } from '../../../shared'
-import { findTypescriptCompiler, getVscodeCliPath } from '../../../shared/utilities/pathFind'
+import { findSshPath, findTypescriptCompiler, getVscodeCliPath } from '../../../shared/utilities/pathFind'
 
 function isWin(): boolean {
     return process.platform === 'win32'
@@ -45,7 +45,49 @@ describe('pathFind', function () {
         assert.ok(regex.test(vscPath), `expected regex ${regex} to match: "${vscPath}"`)
     })
 
-    // describe('findSshPath', function () {
+    describe('findSshPath', function () {
+        it('first tries ssh in $PATH', async function () {
+            const workspace = await testutil.createTestWorkspaceFolder()
+            const fakeSshPath = path.join(workspace.uri.fsPath, `ssh${isWin() ? '.cmd' : ''}`)
 
-    // })
+            await testutil.withEnvPath(workspace.uri.fsPath, async () => {
+                const firstResult = await findSshPath(false)
+
+                await testutil.createExecutableFile(fakeSshPath, 'echo "this is ssh"')
+
+                const secondResult = await findSshPath(false)
+
+                assert.notStrictEqual(firstResult, secondResult)
+                assert.strictEqual(secondResult, 'ssh')
+            })
+        })
+
+        it('only returns executable ssh path', async function () {
+            const workspace = await testutil.createTestWorkspaceFolder()
+            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 () => {
+                const firstResult = await findSshPath(false)
+                assert.notStrictEqual(firstResult, 'ssh')
+            })
+        })
+
+        it('caches result from previous runs', async function () {
+            const workspace = await testutil.createTestWorkspaceFolder()
+            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 () => {
+                const firstResult = await findSshPath(true)
+
+                await fs.delete(fakeSshPath)
+
+                const secondResult = await findSshPath(true)
+
+                assert.strictEqual(firstResult, secondResult)
+                assert.strictEqual(secondResult, 'ssh')
+            })
+        })
+    })
 })

packages/core/src/test/testUtil.ts

@@ -614,3 +614,21 @@ export function tryRegister(command: DeclaredCommand<() => Promise<any>>) {
 export function getFetchStubWithResponse(response: Partial<Response>) {
     return stub(request, 'fetch').returns({ response: new Promise((res, _) => res(response)) } as any)
 }
+
+function setPath(newPath: string): void {
+    process.env.PATH = newPath
+}
+
+function readPath(): string {
+    return process.env.PATH || ''
+}
+
+export async function withEnvPath(newPath: string, task: () => Promise<void>): Promise<void | never> {
+    const originalPath = readPath()
+    setPath(newPath)
+    try {
+        await task()
+    } finally {
+        setPath(originalPath)
+    }
+}