Fix datascience functional tests.

Author: ericsnowcurrently

src/client/common/platform/fileSystem.ts

@@ -323,7 +323,7 @@ export class FileSystemUtils implements IFileSystemUtils {
     ): Promise<boolean> {
         let stat: FileStat;
         try {
-            stat = await this.raw.stat(filename);
+            stat = await this._stat(filename);
         } catch (err) {
             return false;
         }
@@ -371,7 +371,7 @@ export class FileSystemUtils implements IFileSystemUtils {
         try {
             tmpFile = await this.tmp.createFile('___vscpTest___', dirname);
         } catch {
-            await this.raw.stat(dirname); // fails if does not exist
+            await this._stat(dirname); // fails if does not exist
             return true;
         }
         tmpFile.dispose();
@@ -395,6 +395,10 @@ export class FileSystemUtils implements IFileSystemUtils {
             });
         });
     }
+
+    protected async _stat(filename: string): Promise<FileStat> {
+        return this.raw.stat(filename);
+    }
 }
 
 // more aliases (to cause less churn)
@@ -413,7 +417,7 @@ export class FileSystem extends FileSystemUtils implements IFileSystem {
     // aliases
 
     public async stat(filePath: string): Promise<FileStat> {
-        return this.raw.stat(filePath);
+        return this._stat(filePath);
     }
 
     public async readFile(filename: string): Promise<string> {

src/test/datascience/dataScienceIocContainer.ts

@@ -295,6 +295,7 @@ export class DataScienceIocContainer extends UnitTestIocContainer {
 
     constructor() {
         super();
+        this.vscode = false;
         const isRollingBuild = process.env ? process.env.VSCODE_PYTHON_ROLLING !== undefined : false;
         this.shouldMockJupyter = !isRollingBuild;
         this.asyncRegistry = new AsyncDisposableRegistry();

src/test/serviceRegistry.ts

@@ -1,7 +1,9 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+import * as fsextra from 'fs-extra';
 import { Container } from 'inversify';
+import * as path from 'path';
 import { anything, instance, mock, when } from 'ts-mockito';
 import * as TypeMoq from 'typemoq';
 import { Disposable, Memento, OutputChannel } from 'vscode';
@@ -12,7 +14,7 @@ import { FileSystem } from '../client/common/platform/fileSystem';
 import { PathUtils } from '../client/common/platform/pathUtils';
 import { PlatformService } from '../client/common/platform/platformService';
 import { registerTypes as platformRegisterTypes } from '../client/common/platform/serviceRegistry';
-import { IFileSystem, IPlatformService } from '../client/common/platform/types';
+import { FileStat, FileType, IFileSystem, IPlatformService } from '../client/common/platform/types';
 import { BufferDecoder } from '../client/common/process/decoder';
 import { ProcessService } from '../client/common/process/proc';
 import { PythonExecutionFactory } from '../client/common/process/pythonExecutionFactory';
@@ -21,6 +23,7 @@ import { registerTypes as processRegisterTypes } from '../client/common/process/
 import { IBufferDecoder, IProcessServiceFactory, IPythonExecutionFactory, IPythonToolExecutionService } from '../client/common/process/types';
 import { registerTypes as commonRegisterTypes } from '../client/common/serviceRegistry';
 import { GLOBAL_MEMENTO, ICurrentProcess, IDisposableRegistry, ILogger, IMemento, IOutputChannel, IPathUtils, IsWindows, WORKSPACE_MEMENTO } from '../client/common/types';
+import { createDeferred } from '../client/common/utils/async';
 import { registerTypes as variableRegisterTypes } from '../client/common/variables/serviceRegistry';
 import { registerTypes as formattersRegisterTypes } from '../client/formatters/serviceRegistry';
 import { EnvironmentActivationService } from '../client/interpreter/activation/service';
@@ -43,7 +46,77 @@ import { MockMemento } from './mocks/mementos';
 import { MockProcessService } from './mocks/proc';
 import { MockProcess } from './mocks/process';
 
+// This is necessary for unit tests and functional tests, since they
+// do not run under VS Code so they do not have access to the actual
+// "vscode" namespace.
+class LegacyFileSystem extends FileSystem {
+    public async readFile(filename: string): Promise<string> {
+        return fsextra.readFile(filename, 'utf8');
+    }
+    public async writeFile(filename: string, data: {}): Promise<void> {
+        const options: fsextra.WriteFileOptions = {
+            encoding: 'utf8'
+        };
+        return fsextra.writeFile(filename, data, options);
+    }
+    public async deleteDirectory(dirname: string): Promise<void> {
+        return fsextra.stat(dirname)
+            .then(() => fsextra.remove(dirname));
+    }
+    public async deleteFile(filename: string): Promise<void> {
+        return fsextra.unlink(filename);
+    }
+    public async listdir(dirname: string): Promise<[string, FileType][]> {
+        const names: string[] = await fsextra.readdir(dirname);
+        const promises = names
+            .map(name => {
+                 const filename = path.join(dirname, name);
+                 return this.raw.lstat(filename)
+                     .then(stat => [name, stat.type] as [string, FileType])
+                     .catch(() => [name, FileType.Unknown] as [string, FileType]);
+            });
+        return Promise.all(promises);
+    }
+    public async createDirectory(dirname: string): Promise<void> {
+        return fsextra.mkdirp(dirname);
+    }
+    public async copyFile(src: string, dest: string): Promise<void> {
+        const deferred = createDeferred<void>();
+        const rs = fsextra.createReadStream(src)
+            .on('error', (err) => {
+                deferred.reject(err);
+            });
+        const ws = fsextra.createWriteStream(dest)
+            .on('error', (err) => {
+                deferred.reject(err);
+            }).on('close', () => {
+                deferred.resolve();
+            });
+        rs.pipe(ws);
+        return deferred.promise;
+    }
+    protected async _stat(filePath: string): Promise<FileStat> {
+        const stat = await fsextra.stat(filePath);
+        let fileType = FileType.Unknown;
+        if (stat.isFile()) {
+            fileType = FileType.File;
+        } else if (stat.isDirectory()) {
+            fileType = FileType.Directory;
+        } else if (stat.isSymbolicLink()) {
+            fileType = FileType.SymbolicLink;
+        }
+        return {
+            type: fileType,
+            size: stat.size,
+            ctime: stat.ctimeMs,
+            mtime: stat.mtimeMs
+        };
+    }
+}
+
 export class IocContainer {
+    public vscode = true;
+
     public readonly serviceManager: IServiceManager;
     public readonly serviceContainer: IServiceContainer;
 
@@ -90,7 +163,10 @@ export class IocContainer {
     }
     public registerFileSystemTypes() {
         this.serviceManager.addSingleton<IPlatformService>(IPlatformService, PlatformService);
-        this.serviceManager.addSingleton<IFileSystem>(IFileSystem, FileSystem);
+        this.serviceManager.addSingleton<IFileSystem>(
+            IFileSystem,
+            this.vscode ? FileSystem : LegacyFileSystem
+        );
     }
     public registerProcessTypes() {
         processRegisterTypes(this.serviceManager);