Use the new API for copyFile().

Author: ericsnowcurrently

src/client/common/platform/fileSystem.ts

@@ -11,7 +11,6 @@ import { injectable } from 'inversify';
 import * as fspath from 'path';
 import * as tmpMod from 'tmp';
 import * as vscode from 'vscode';
-import { createDeferred } from '../utils/async';
 import { getOSType, OSType } from '../utils/platform';
 import {
     FileStat, FileType,
@@ -97,7 +96,7 @@ export class TempFileSystem {
 
 // This is the parts of the vscode.workspace.fs API that we use here.
 interface INewAPI {
-    //copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
+    copy(source: vscode.Uri, target: vscode.Uri, options?: {overwrite: boolean}): Thenable<void>;
     //createDirectory(uri: vscode.Uri): Thenable<void>;
     delete(uri: vscode.Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: vscode.Uri): Thenable<[string, FileType][]>;
@@ -125,8 +124,6 @@ interface IRawFSExtra {
     // non-async
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
 }
 
 //interface IRawPath {
@@ -186,6 +183,14 @@ export class RawFileSystem implements IRawFileSystem {
         return this.newapi.readDirectory(uri);
     }
 
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const srcURI = vscode.Uri.file(src);
+        const destURI = vscode.Uri.file(dest);
+        await this.newapi.copy(srcURI, destURI, {
+            overwrite: true
+        });
+    }
+
     //****************************
     // fs-extra
 
@@ -203,22 +208,6 @@ export class RawFileSystem implements IRawFileSystem {
         return convertFileStat(stat);
     }
 
-    public async copyFile(src: string, dest: string): Promise<void> {
-        const deferred = createDeferred<void>();
-        const rs = this.fsExtra.createReadStream(src)
-            .on('error', (err) => {
-                deferred.reject(err);
-            });
-        const ws = this.fsExtra.createWriteStream(dest)
-            .on('error', (err) => {
-                deferred.reject(err);
-            }).on('close', () => {
-                deferred.resolve();
-            });
-        rs.pipe(ws);
-        return deferred.promise;
-    }
-
     //****************************
     // non-async (fs-extra)
 

src/test/common/platform/filesystem.functional.test.ts

@@ -311,58 +311,6 @@ suite('Raw FileSystem', () => {
         });
     });
 
-    suite('copyFile', () => {
-        test('the source file gets copied (same directory)', async () => {
-            const data = '<content>';
-            const src = await fix.createFile('x/y/z/spam.py', data);
-            const dest = await fix.resolve('x/y/z/spam.py.bak');
-            await ensureDoesNotExist(dest);
-
-            await filesystem.copyFile(src, dest);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.readFile(src)
-                .then(buffer => buffer.toString());
-            expect(original).to.equal(data);
-        });
-
-        test('the source file gets copied (different directory)', async () => {
-            const data = '<content>';
-            const src = await fix.createFile('x/y/z/spam.py', data);
-            const dest = await fix.resolve('x/y/eggs.py');
-            await ensureDoesNotExist(dest);
-
-            await filesystem.copyFile(src, dest);
-
-            const actual = await fsextra.readFile(dest)
-                .then(buffer => buffer.toString());
-            expect(actual).to.equal(data);
-            const original = await fsextra.readFile(src)
-                .then(buffer => buffer.toString());
-            expect(original).to.equal(data);
-        });
-
-        test('fails if the source does not exist', async () => {
-            const dest = await fix.resolve('x/spam.py');
-
-            const promise = filesystem.copyFile(DOES_NOT_EXIST, dest);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-
-        test('fails if the target parent directory does not exist', async () => {
-            const src = await fix.createFile('x/spam.py', '...');
-            const dest = await fix.resolve('y/eggs.py', false);
-            await ensureDoesNotExist(path.dirname(dest));
-
-            const promise = filesystem.copyFile(src, dest);
-
-            await expect(promise).to.eventually.be.rejected;
-        });
-    });
-
     suite('statSync', () => {
         test('gets the info for an existing file', async () => {
             const filename = await fix.createFile('x/y/z/spam.py', '...');

src/test/common/platform/filesystem.test.ts

@@ -239,6 +239,58 @@ suite('Raw FileSystem', () => {
             await expect(promise).to.eventually.be.rejected;
         });
     });
+
+    suite('copyFile', () => {
+        test('the source file gets copied (same directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/z/spam.py.bak');
+            await ensureDoesNotExist(dest);
+
+            await filesystem.copyFile(src, dest);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('the source file gets copied (different directory)', async () => {
+            const data = '<content>';
+            const src = await fix.createFile('x/y/z/spam.py', data);
+            const dest = await fix.resolve('x/y/eggs.py');
+            await ensureDoesNotExist(dest);
+
+            await filesystem.copyFile(src, dest);
+
+            const actual = await fsextra.readFile(dest)
+                .then(buffer => buffer.toString());
+            expect(actual).to.equal(data);
+            const original = await fsextra.readFile(src)
+                .then(buffer => buffer.toString());
+            expect(original).to.equal(data);
+        });
+
+        test('fails if the source does not exist', async () => {
+            const dest = await fix.resolve('x/spam.py');
+
+            const promise = filesystem.copyFile(DOES_NOT_EXIST, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+
+        test('fails if the target parent directory does not exist', async () => {
+            const src = await fix.createFile('x/spam.py', '...');
+            const dest = await fix.resolve('y/eggs.py', false);
+            await ensureDoesNotExist(path.dirname(dest));
+
+            const promise = filesystem.copyFile(src, dest);
+
+            await expect(promise).to.eventually.be.rejected;
+        });
+    });
 });
 
 suite('FileSystem Utils', () => {

src/test/common/platform/filesystem.unit.test.ts

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 import { expect } from 'chai';
+import * as fs from 'fs';
 import * as fsextra from 'fs-extra';
 import * as TypeMoq from 'typemoq';
 import { Disposable, Uri } from 'vscode';
@@ -20,6 +21,7 @@ import {
 type TempCallback = (err: any, path: string, fd: number, cleanupCallback: () => void) => void;
 interface IRawFS {
     // VS Code
+    copy(source: Uri, target: Uri, options?: {overwrite: boolean}): Thenable<void>;
     delete(uri: Uri, options?: {recursive: boolean; useTrash: boolean}): Thenable<void>;
     readDirectory(uri: Uri): Thenable<[string, FileType][]>;
     readFile(uri: Uri): Thenable<Uint8Array>;
@@ -31,15 +33,14 @@ interface IRawFS {
     open(filename: string, flags: number, callback: any): void;
     //tslint:disable-next-line:no-any
     close(fd: number, callback: any): void;
+    createWriteStream(dest: string): fs.WriteStream;
 
     // "fs-extra"
     chmod(filePath: string, mode: string): Promise<void>;
     lstat(filename: string): Promise<fsextra.Stats>;
     mkdirp(dirname: string): Promise<void>;
     statSync(filename: string): fsextra.Stats;
     readFileSync(path: string, encoding: string): string;
-    createReadStream(src: string): fsextra.ReadStream;
-    createWriteStream(dest: string): fsextra.WriteStream;
 
     // node "path"
     join(...filenames: string[]): string;
@@ -501,48 +502,14 @@ suite('Raw FileSystem', () => {
     });
 
     suite('copyFile', () => {
-        let rs: TypeMoq.IMock<fsextra.ReadStream>;
-        let ws: TypeMoq.IMock<fsextra.WriteStream>;
-        let done: () => void;
-        let finished: boolean;
-        setup(() => {
-            rs = TypeMoq.Mock.ofType<fsextra.ReadStream>(undefined, TypeMoq.MockBehavior.Strict);
-            ws = TypeMoq.Mock.ofType<fsextra.WriteStream>(undefined, TypeMoq.MockBehavior.Strict);
-
-            rs.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => rs.object);
-            finished = false;
-            done = () => {
-                throw Error();
-            };
-            rs.setup(s => s.pipe(TypeMoq.It.isAny()))
-                .callback(_r => {
-                    done();
-                    finished = true;
-                });
-
-            ws.setup(s => s.on('error', TypeMoq.It.isAny()))
-                .returns(() => ws.object);
-            ws.setup(s => s.on('close', TypeMoq.It.isAny()))
-                .callback((_e, cb) => {
-                    done = cb;
-                })
-                .returns(() => ws.object);
-        });
-
         test('read/write streams are used properly', async () => {
             const src = 'x/y/z/spam.py';
             const dest = 'x/y/z/spam.py.bak';
-            raw.setup(r => r.createReadStream(src))
-                .returns(() => rs.object);
-            raw.setup(r => r.createWriteStream(dest))
-                .returns(() => ws.object);
+            raw.setup(r => r.copy(Uri.file(src), Uri.file(dest), { overwrite: true }))
+                .returns(() => Promise.resolve());
 
             await filesystem.copyFile(src, dest);
 
-            expect(finished).to.equal(true);
-            rs.verifyAll();
-            ws.verifyAll();
             verifyAll();
         });
     });