chore: add tests on resource operations

Author: cdaguerre

lib/adapters/apply-edit-adapter.ts

@@ -12,7 +12,8 @@ import {
   DocumentUri
 } from "../languageclient"
 import { TextBuffer, TextEditor } from "atom"
-import * as fs from 'fs';
+import * as fs from "fs"
+import * as rimraf from "rimraf"
 
 /** Public: Adapts workspace/applyEdit commands to editors. */
 export default class ApplyEditAdapter {
@@ -49,14 +50,16 @@ export default class ApplyEditAdapter {
 
   public static async apply(workspaceEdit: WorkspaceEdit): Promise<ApplyWorkspaceEditResponse> {
     ApplyEditAdapter.normalize(workspaceEdit)
-    
+
     // Keep checkpoints from all successful buffer edits
     const checkpoints: Array<{ buffer: TextBuffer; checkpoint: number }> = []
 
     const promises = (workspaceEdit.documentChanges || []).map(async (edit): Promise<void> => {
       if (!TextDocumentEdit.is(edit)) {
-        return ApplyEditAdapter.handleResourceOperation(edit)
-      } 
+        return ApplyEditAdapter.handleResourceOperation(edit).catch((err) => {
+          throw Error(`Error during ${edit.kind} resource operation: ${err.message}`)
+        })
+      }
       const path = Convert.uriToPath(edit.textDocument.uri)
       const editor = (await atom.workspace.open(path, {
         searchAllPanes: true,
@@ -87,23 +90,72 @@ export default class ApplyEditAdapter {
     return { applied }
   }
 
-  private static async handleResourceOperation(edit: (CreateFile | RenameFile | DeleteFile)): Promise<void>
-  {
+  private static async handleResourceOperation(edit: (CreateFile | RenameFile | DeleteFile)): Promise<void> {
     if (DeleteFile.is(edit)) {
-      return fs.promises.unlink(Convert.uriToPath(edit.uri))
+      const path = Convert.uriToPath(edit.uri)
+      const exists = fs.existsSync(path)
+      const ignoreIfNotExists = edit.options?.ignoreIfNotExists
+
+      if (!exists) {
+        if (ignoreIfNotExists) {
+          return
+        }
+        throw Error(`Target doesn't exist.`)
+      }
+
+      const isDirectory = fs.lstatSync(path).isDirectory()
+
+      if (isDirectory) {
+        if (edit.options?.recursive) {
+          return new Promise((resolve, reject) => {
+            rimraf(path, { glob: false }, (err) => {
+              if (err) {
+                reject(err)
+              }
+              resolve()
+            })
+          })
+        }
+        return fs.promises.rmdir(path, { recursive: edit.options?.recursive })
+      }
+
+      return fs.promises.unlink(path)
     }
     if (RenameFile.is(edit)) {
-      return fs.promises.rename(Convert.uriToPath(edit.oldUri), Convert.uriToPath(edit.newUri))
+      const oldPath = Convert.uriToPath(edit.oldUri)
+      const newPath = Convert.uriToPath(edit.newUri)
+      const exists = fs.existsSync(newPath)
+      const ignoreIfExists = edit.options?.ignoreIfExists
+      const overwrite = edit.options?.overwrite
+
+      if (exists && ignoreIfExists && !overwrite) {
+        return
+      }
+
+      if (exists && !ignoreIfExists && !overwrite) {
+        throw Error(`Target exists.`)
+      }
+
+      return fs.promises.rename(oldPath, newPath)
     }
     if (CreateFile.is(edit)) {
-      return fs.promises.writeFile(edit.uri, '')
+      const path = Convert.uriToPath(edit.uri)
+      const exists = fs.existsSync(path)
+      const ignoreIfExists = edit.options?.ignoreIfExists
+      const overwrite = edit.options?.overwrite
+
+      if (exists && ignoreIfExists && !overwrite) {
+        return
+      }
+
+      return fs.promises.writeFile(path, '')
     }
-  } 
+  }
 
   private static normalize(workspaceEdit: WorkspaceEdit): void {
     const documentChanges = workspaceEdit.documentChanges || []
 
-    if (!workspaceEdit.hasOwnProperty('documentChanges') && workspaceEdit.hasOwnProperty('changes')) {
+    if (!('documentChanges' in workspaceEdit) && ('changes' in workspaceEdit)) {
       Object.keys(workspaceEdit.changes || []).forEach((uri: DocumentUri) => {
         documentChanges.push({
           textDocument: {
@@ -114,7 +166,7 @@ export default class ApplyEditAdapter {
         })
       })
     }
-    
+
     workspaceEdit.documentChanges = documentChanges
   }
 

package.json

@@ -25,7 +25,9 @@
   },
   "atomTestRunner": "./test/runner",
   "dependencies": {
+    "@types/rimraf": "^3.0.0",
     "atom-ide-base": "^2.4.0",
+    "rimraf": "^3.0.2",
     "vscode-jsonrpc": "6.0.0",
     "vscode-languageserver-protocol": "3.16.0",
     "vscode-languageserver-types": "3.16.0",

test/adapters/apply-edit-adapter.test.ts

@@ -1,5 +1,7 @@
 import { expect } from "chai"
 import * as path from "path"
+import * as os from "os"
+import * as fs from "fs"
 import * as sinon from "sinon"
 import ApplyEditAdapter from "../../lib/adapters/apply-edit-adapter"
 import Convert from "../../lib/convert"
@@ -9,6 +11,7 @@ const TEST_PATH1 = normalizeDriveLetterName(path.join(__dirname, "test.txt"))
 const TEST_PATH2 = normalizeDriveLetterName(path.join(__dirname, "test2.txt"))
 const TEST_PATH3 = normalizeDriveLetterName(path.join(__dirname, "test3.txt"))
 const TEST_PATH4 = normalizeDriveLetterName(path.join(__dirname, "test4.txt"))
+const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atom-languageclient-tests'))
 
 function normalizeDriveLetterName(filePath: string): string {
   if (process.platform === "win32") {
@@ -186,5 +189,235 @@ describe("ApplyEditAdapter", () => {
       expect(errorCalls.length).to.equal(1)
       expect(errorCalls[0].args[1].detail).to.equal(`Out of range edit on ${TEST_PATH4}:1:2`)
     })
+
+    it("handles rename resource operations", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const oldUri = path.join(directory, "test.txt")
+      const newUri = path.join(directory, "test-renamed.txt")
+      fs.writeFileSync(oldUri, 'abcd')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "rename",
+              oldUri: oldUri,
+              newUri: newUri,
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(newUri)).to.equal(true)
+      expect(fs.readFileSync(newUri).toString()).to.equal('abcd')
+      expect(fs.existsSync(oldUri)).to.equal(false)
+    })
+
+    it("handles rename operation with ignoreIfExists option", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const oldUri = path.join(directory, "test.txt")
+      const newUri = path.join(directory, "test-renamed.txt")
+      fs.writeFileSync(oldUri, 'abcd')
+      fs.writeFileSync(newUri, 'efgh')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "rename",
+              oldUri: oldUri,
+              newUri: newUri,
+              options: {
+                ignoreIfExists: true
+              }
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(oldUri)).to.equal(true)
+      expect(fs.readFileSync(newUri).toString()).to.equal('efgh')
+    })
+
+    it("handles rename operation with overwrite option", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const oldUri = path.join(directory, "test.txt")
+      const newUri = path.join(directory, "test-renamed.txt")
+      fs.writeFileSync(oldUri, 'abcd')
+      fs.writeFileSync(newUri, 'efgh')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "rename",
+              oldUri: oldUri,
+              newUri: newUri,
+              options: {
+                overwrite: true,
+                ignoreIfExists: true // Overwrite wins over ignoreIfExists
+              }
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(oldUri)).to.equal(false)
+      expect(fs.readFileSync(newUri).toString()).to.equal('abcd')
+    })
+
+    it("throws an error on rename operation if target exists", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const oldUri = path.join(directory, "test.txt")
+      const newUri = path.join(directory, "test-renamed.txt")
+      fs.writeFileSync(oldUri, 'abcd')
+      fs.writeFileSync(newUri, 'efgh')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "rename",
+              oldUri: oldUri,
+              newUri: newUri,
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(false)
+      expect(fs.existsSync(oldUri)).to.equal(true)
+      expect(fs.readFileSync(oldUri).toString()).to.equal('abcd')
+      expect(fs.existsSync(newUri)).to.equal(true)
+      expect(fs.readFileSync(newUri).toString()).to.equal('efgh')
+
+      expect(
+        (atom as any).notifications.addError.calledWith("workspace/applyEdits failed", {
+          description: "Failed to apply edits.",
+          detail: "Error during rename resource operation: Target exists.",
+        })
+      ).to.equal(true)
+    })
+
+    it("handles delete resource operations on files", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const uri = path.join(directory, "test.txt")
+      fs.writeFileSync(uri, 'abcd')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "delete",
+              uri: uri
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(uri)).to.equal(false)
+    })
+
+    it("handles delete resource operations on directories", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const file1 = path.join(directory, '1.txt')
+      const file2 = path.join(directory, '2.txt')
+      fs.writeFileSync(file1, '1')
+      fs.writeFileSync(file2, '2')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "delete",
+              uri: directory,
+              options: {
+                recursive: true
+              }
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(directory)).to.equal(false)
+      expect(fs.existsSync(file1)).to.equal(false)
+      expect(fs.existsSync(file2)).to.equal(false)
+    })
+
+    it("throws an error when deleting a non-empty directory without recursive option", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const file1 = path.join(directory, '1.txt')
+      const file2 = path.join(directory, '2.txt')
+      fs.writeFileSync(file1, '1')
+      fs.writeFileSync(file2, '2')
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "delete",
+              uri: directory,
+              options: {
+                recursive: false
+              }
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(false)
+      expect(fs.existsSync(directory)).to.equal(true)
+      expect(fs.existsSync(file1)).to.equal(true)
+      expect(fs.existsSync(file2)).to.equal(true)
+      const errorCalls = (atom as any).notifications.addError.getCalls()
+      expect(errorCalls.length).to.equal(1)
+      expect(errorCalls[0].args[1].detail).to.match(/Error during delete resource operation: (.*)/)
+    })
+
+
+    it("throws an error on delete operation if target doesnt exist", async () => {
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "delete",
+              uri: path.join(tempDir, "unexisting.txt"),
+            }
+          ]
+        },
+      })
+      //
+      expect(result.applied).to.equal(false)
+      expect(
+        (atom as any).notifications.addError.calledWith("workspace/applyEdits failed", {
+          description: "Failed to apply edits.",
+          detail: "Error during delete resource operation: Target doesn't exist.",
+        })
+      ).to.equal(true)
+    })
+
+    it("handles create resource operations", async () => {
+      const directory = fs.mkdtempSync(tempDir)
+      const uri = path.join(directory, "test.txt")
+
+      const result = await ApplyEditAdapter.onApplyEdit({
+        edit: {
+          documentChanges: [
+            {
+              kind: "create",
+              uri: uri
+            }
+          ]
+        },
+      })
+
+      expect(result.applied).to.equal(true)
+      expect(fs.existsSync(uri)).to.equal(true)
+    })
   })
 })