fix: Use 'fs' methods if in C9 (#4374)

* fix: Use 'fs' methods if in C9

Problem:

We recently made some changes to our file system code
that used the vscode.workspace.fs instance. The issue
is that some of its methods are not supported in C9

Solution:

If in C9 use the original "fs" instance methods instead
for delete, readdir, and mkdir.

Also added tests.

Signed-off-by: nkomonen <[email protected]>

* changelog item

Signed-off-by: nkomonen <[email protected]>

---------

Signed-off-by: nkomonen <[email protected]>

Author: nkomonen-amazon

.changes/next-release/Bug Fix-58f92b8d-fe98-4885-b150-3c52d640b4a0.json

@@ -0,0 +1,4 @@
+{
+	"type": "Bug Fix",
+	"description": "Cloud9: certain filesystem calls did not work in Cloud9"
+}

aws-toolkit-vscode-C9-Fs-Fix.vsix.zip

@@ -3,9 +3,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import * as vscode from 'vscode'
-import * as actualFs from 'fs'
+import { promises as fsPromises } from 'fs'
 import { isCloud9 } from '../shared/extensionUtilities'
-import { ToolkitError } from '../shared/errors'
 import _path from 'path'
 
 const fs = vscode.workspace.fs
@@ -44,9 +43,8 @@ export class FileSystemCommon {
         // Certain URIs are not supported with vscode.workspace.fs in C9
         // so revert to using `fs` which works.
         if (isCloud9()) {
-            return actualFs.mkdir(uriPath.fsPath, { recursive: true }, err => {
-                throw new ToolkitError(`Failed mkdir() in Cloud9: ${uriPath.fsPath}: ${err}`)
-            })
+            await fsPromises.mkdir(uriPath.fsPath, { recursive: true })
+            return
         }
 
         return fs.createDirectory(uriPath)
@@ -120,11 +118,27 @@ export class FileSystemCommon {
 
     async delete(uri: vscode.Uri | string): Promise<void> {
         const path = FileSystemCommon.getUri(uri)
+
+        // vscode.workspace.fs.delete is not supported in C9
+        if (isCloud9()) {
+            await fsPromises.rm(path.fsPath, { recursive: true })
+            return
+        }
+
         return fs.delete(path, { recursive: true })
     }
 
     async readdir(uri: vscode.Uri | string): Promise<[string, vscode.FileType][]> {
         const path = FileSystemCommon.getUri(uri)
+
+        // readdir is not a supported vscode API in Cloud9
+        if (isCloud9()) {
+            return (await fsPromises.readdir(path.fsPath, { withFileTypes: true })).map(e => [
+                e.name,
+                e.isDirectory() ? vscode.FileType.Directory : vscode.FileType.File,
+            ])
+        }
+
         return await fs.readDirectory(path)
     }
 

src/srcShared/fs.ts

@@ -6,29 +6,34 @@
 import assert from 'assert'
 import * as vscode from 'vscode'
 import * as path from 'path'
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'fs'
+import { existsSync, mkdirSync, promises as fsPromises, readFileSync, rmSync, writeFileSync } from 'fs'
 import { FakeExtensionContext } from '../fakeExtensionContext'
 import { fsCommon } from '../../srcShared/fs'
 import * as os from 'os'
 import { isMinimumVersion } from '../../shared/vscode/env'
+import Sinon from 'sinon'
+import * as extensionUtilities from '../../shared/extensionUtilities'
 
 function isWin() {
     return os.platform() === 'win32'
 }
 
 describe('FileSystem', function () {
     let fakeContext: vscode.ExtensionContext
+    let sandbox: Sinon.SinonSandbox
 
     before(async function () {
         fakeContext = await FakeExtensionContext.create()
     })
 
     beforeEach(async function () {
         await makeTestRoot()
+        sandbox = Sinon.createSandbox()
     })
 
     afterEach(async function () {
         await deleteTestRoot()
+        sandbox.restore()
     })
 
     describe('readFileAsString()', function () {
@@ -153,12 +158,25 @@ describe('FileSystem', function () {
         const paths = ['a', 'a/b', 'a/b/c', 'a/b/c/d/']
 
         paths.forEach(async function (p) {
-            it(`creates path: '${p}'`, async function () {
+            it(`creates folder: '${p}'`, async function () {
                 const dirPath = createTestPath(p)
                 await fsCommon.mkdir(dirPath)
                 assert.ok(existsSync(dirPath))
             })
         })
+
+        paths.forEach(async function (p) {
+            it(`creates folder but uses the "fs" module if in C9: '${p}'`, async function () {
+                sandbox.stub(extensionUtilities, 'isCloud9').returns(true)
+                const mkdirSpy = sandbox.spy(fsPromises, 'mkdir')
+                const dirPath = createTestPath(p)
+
+                await fsCommon.mkdir(dirPath)
+
+                assert.ok(existsSync(dirPath))
+                assert.ok(mkdirSpy.calledOnce)
+            })
+        })
     })
 
     describe('readdir()', function () {
@@ -192,6 +210,32 @@ describe('FileSystem', function () {
         function sorted(i: [string, vscode.FileType][]) {
             return i.sort((a, b) => a[0].localeCompare(b[0]))
         }
+
+        it('uses the "fs" readdir implementation if in C9', async function () {
+            sandbox.stub(extensionUtilities, 'isCloud9').returns(true)
+            const readdirSpy = sandbox.spy(fsPromises, 'readdir')
+
+            await makeFile('a.txt')
+            await makeFile('b.txt')
+            await makeFile('c.txt')
+            mkdirSync(createTestPath('dirA'))
+            mkdirSync(createTestPath('dirB'))
+            mkdirSync(createTestPath('dirC'))
+
+            const files = await fsCommon.readdir(testRootPath())
+            assert.deepStrictEqual(
+                sorted(files),
+                sorted([
+                    ['a.txt', vscode.FileType.File],
+                    ['b.txt', vscode.FileType.File],
+                    ['c.txt', vscode.FileType.File],
+                    ['dirA', vscode.FileType.Directory],
+                    ['dirB', vscode.FileType.Directory],
+                    ['dirC', vscode.FileType.Directory],
+                ])
+            )
+            assert.ok(readdirSpy.calledOnce)
+        })
     })
 
     describe('delete()', function () {
@@ -209,6 +253,20 @@ describe('FileSystem', function () {
 
             assert.ok(!existsSync(dirPath))
         })
+
+        it('uses the "fs" rm method if in C9', async function () {
+            sandbox.stub(extensionUtilities, 'isCloud9').returns(true)
+            const rmdirSpy = sandbox.spy(fsPromises, 'rm')
+            // Folder with subfolders
+            const dirPath = await makeFolder('a/b/deleteMe')
+
+            mkdirSync(dirPath, { recursive: true })
+
+            await fsCommon.delete(dirPath)
+
+            assert.ok(!existsSync(dirPath))
+            assert.ok(rmdirSpy.calledOnce)
+        })
     })
 
     describe('stat()', function () {