Remove Homebrew installation

src/client/common/installer/pythonInstallation.ts

@@ -2,116 +2,38 @@
 // Licensed under the MIT License.
 'use strict';
 
-import { OutputChannel } from 'vscode';
 import { IInterpreterLocatorService, INTERPRETER_LOCATOR_SERVICE, InterpreterType } from '../../interpreter/contracts';
 import { IServiceContainer } from '../../ioc/types';
 import { IApplicationShell } from '../application/types';
 import { IPythonSettings } from '../configSettings';
-import { STANDARD_OUTPUT_CHANNEL } from '../constants';
-import { IFileSystem, IPlatformService } from '../platform/types';
-import { IProcessService } from '../process/types';
-import { IOutputChannel } from '../types';
+import { IPlatformService } from '../platform/types';
 
 export class PythonInstaller {
     private locator: IInterpreterLocatorService;
-    private process: IProcessService;
-    private fs: IFileSystem;
-    private outputChannel: OutputChannel;
-    private _platform: IPlatformService;
-    private _shell: IApplicationShell;
+    private shell: IApplicationShell;
 
     constructor(private serviceContainer: IServiceContainer) {
         this.locator = serviceContainer.get<IInterpreterLocatorService>(IInterpreterLocatorService, INTERPRETER_LOCATOR_SERVICE);
+        this.shell = serviceContainer.get<IApplicationShell>(IApplicationShell);
    }
 
     public async checkPythonInstallation(settings: IPythonSettings): Promise<boolean> {
         if (settings.disableInstallationChecks === true) {
             return true;
         }
-        let interpreters = await this.locator.getInterpreters();
+        const interpreters = await this.locator.getInterpreters();
         if (interpreters.length > 0) {
-            if (this.platform.isMac &&
+            const platform = this.serviceContainer.get<IPlatformService>(IPlatformService);
+            if (platform.isMac &&
                 settings.pythonPath === 'python' &&
                 interpreters[0].type === InterpreterType.Unknown) {
-                await this.shell.showWarningMessage('Selected interpreter is MacOS system Python which is not recommended. Please select different interpreter');
+                await this.shell.showWarningMessage('Selected interpreter is macOS system Python which is not recommended. Please select different interpreter');
             }
             return true;
         }
 
-        if (!this.platform.isMac) {
-            // Windows or Linux
-            await this.shell.showErrorMessage('Python is not installed. Please download and install Python before using the extension.');
-            this.shell.openUrl('https://www.python.org/downloads');
-            return false;
-        }
-
-        this.process = this.serviceContainer.get<IProcessService>(IProcessService);
-        this.fs = this.serviceContainer.get<IFileSystem>(IFileSystem);
-        this.outputChannel = this.serviceContainer.get<OutputChannel>(IOutputChannel, STANDARD_OUTPUT_CHANNEL);
-
-        if (this.platform.isMac) {
-            if (await this.shell.showErrorMessage('Python that comes with MacOS is not supported. Would you like to install regular Python now?', 'Yes', 'No') === 'Yes') {
-                const brewInstalled = await this.ensureBrew();
-                if (!brewInstalled) {
-                    await this.shell.showErrorMessage('Unable to install Homebrew package manager. Try installing it manually.');
-                    this.shell.openUrl('https://brew.sh');
-                    return false;
-                }
-                await this.executeAndOutput('brew', ['install', 'python']);
-            }
-        }
-
-        interpreters = await this.locator.getInterpreters();
-        return interpreters.length > 0;
-    }
-
-    private isBrewInstalled(): Promise<boolean> {
-        return this.fs.fileExistsAsync('/usr/local/bin/brew');
-    }
-
-    private async ensureBrew(): Promise<boolean> {
-        if (await this.isBrewInstalled()) {
-            return true;
-        }
-        const result = await this.executeAndOutput(
-            '/usr/bin/ruby',
-            ['-e', '"$(curl -fsSL https://github.com/raw/Homebrew/install/master/install)"']);
-        return result && await this.isBrewInstalled();
-    }
-
-    private executeAndOutput(command: string, args: string[]): Promise<boolean> {
-        let failed = false;
-        this.outputChannel.show();
-
-        const result = this.process.execObservable(command, args, { mergeStdOutErr: true, throwOnStdErr: false });
-        result.out.subscribe(output => {
-            this.outputChannel.append(output.out);
-        }, error => {
-            failed = true;
-            this.shell.showErrorMessage(`Unable to execute '${command}', error: ${error}`);
-        });
-
-        return new Promise<boolean>((resolve, reject) => {
-            if (failed) {
-                resolve(false);
-            }
-            result.proc.on('exit', (code, signal) => {
-                resolve(!signal);
-            });
-        });
-    }
-
-    private get shell(): IApplicationShell {
-        if (!this._shell) {
-            this._shell = this.serviceContainer.get<IApplicationShell>(IApplicationShell);
-        }
-        return this._shell;
-    }
-
-    private get platform(): IPlatformService {
-        if (!this._platform) {
-            this._platform = this.serviceContainer.get<IPlatformService>(IPlatformService);
-        }
-        return this._platform;
+        await this.shell.showErrorMessage('Python is not installed. Please download and install Python before using the extension.');
+        this.shell.openUrl('https://www.python.org/downloads');
+        return false;
     }
 }

src/test/install/pythonInstallation.test.ts

@@ -12,9 +12,7 @@ import { IApplicationShell } from '../../client/common/application/types';
 import { IPythonSettings } from '../../client/common/configSettings';
 import { STANDARD_OUTPUT_CHANNEL } from '../../client/common/constants';
 import { PythonInstaller } from '../../client/common/installer/pythonInstallation';
-import { IFileSystem, IPlatformService } from '../../client/common/platform/types';
-import { IProcessService, ObservableExecutionResult, Output } from '../../client/common/process/types';
-import { IOutputChannel } from '../../client/common/types';
+import { IPlatformService } from '../../client/common/platform/types';
 import { IInterpreterLocatorService } from '../../client/interpreter/contracts';
 import { InterpreterType, PythonInterpreter } from '../../client/interpreter/contracts';
 import { ServiceContainer } from '../../client/ioc/container';
@@ -26,12 +24,9 @@ class TestContext {
     public serviceManager: ServiceManager;
     public serviceContainer: IServiceContainer;
     public platform: TypeMoq.IMock<IPlatformService>;
-    public fileSystem: TypeMoq.IMock<IFileSystem>;
     public appShell: TypeMoq.IMock<IApplicationShell>;
     public locator: TypeMoq.IMock<IInterpreterLocatorService>;
     public settings: TypeMoq.IMock<IPythonSettings>;
-    public process: TypeMoq.IMock<IProcessService>;
-    public output: TypeMoq.IMock<vscode.OutputChannel>;
     public pythonInstaller: PythonInstaller;
 
     constructor(isMac: boolean) {
@@ -40,19 +35,13 @@ class TestContext {
         this.serviceContainer = new ServiceContainer(cont);
 
         this.platform = TypeMoq.Mock.ofType<IPlatformService>();
-        this.fileSystem = TypeMoq.Mock.ofType<IFileSystem>();
         this.appShell = TypeMoq.Mock.ofType<IApplicationShell>();
         this.locator = TypeMoq.Mock.ofType<IInterpreterLocatorService>();
         this.settings = TypeMoq.Mock.ofType<IPythonSettings>();
-        this.process = TypeMoq.Mock.ofType<IProcessService>();
-        this.output = TypeMoq.Mock.ofType<vscode.OutputChannel>();
 
         this.serviceManager.addSingletonInstance<IPlatformService>(IPlatformService, this.platform.object);
-        this.serviceManager.addSingletonInstance<IFileSystem>(IFileSystem, this.fileSystem.object);
         this.serviceManager.addSingletonInstance<IApplicationShell>(IApplicationShell, this.appShell.object);
         this.serviceManager.addSingletonInstance<IInterpreterLocatorService>(IInterpreterLocatorService, this.locator.object);
-        this.serviceManager.addSingletonInstance<IProcessService>(IProcessService, this.process.object);
-        this.serviceManager.addSingletonInstance<vscode.OutputChannel>(IOutputChannel, this.output.object, STANDARD_OUTPUT_CHANNEL);
         this.pythonInstaller = new PythonInstaller(this.serviceContainer);
 
         this.platform.setup(x => x.isMac).returns(() => isMac);
@@ -80,7 +69,7 @@ suite('Installation', () => {
         assert.equal(showErrorMessageCalled, false, 'Disabling checks has no effect');
     });
 
-    test('Windows: Python missing', async () => {
+    test('Python missing', async () => {
         const c = new TestContext(false);
         let showErrorMessageCalled = false;
         let openUrlCalled = false;
@@ -100,7 +89,7 @@ suite('Installation', () => {
         assert.equal(url, 'https://www.python.org/downloads', 'Python download page is incorrect');
     });
 
-    test('Mac: Python missing', async () => {
+    test('Mac: Default Python warning', async () => {
         const c = new TestContext(true);
         let called = false;
         c.appShell.setup(x => x.showWarningMessage(TypeMoq.It.isAnyString())).callback(() => called = true);
@@ -115,89 +104,4 @@ suite('Installation', () => {
         assert.equal(passed, true, 'Default MacOS Python not accepted');
         assert.equal(called, true, 'Warning not shown');
     });
-
-    test('Mac: Default Python, user refused install', async () => {
-        const c = new TestContext(true);
-        let errorMessage = '';
-
-        c.appShell
-            .setup(x => x.showErrorMessage(TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString()))
-            .callback((m: string, a1: string, a2: string) => errorMessage = m)
-            .returns(() => Promise.resolve('No'));
-        c.locator.setup(x => x.getInterpreters()).returns(() => Promise.resolve([]));
-
-        const passed = await c.pythonInstaller.checkPythonInstallation(c.settings.object);
-        assert.equal(passed, false, 'Default MacOS Python accepted');
-        assert.equal(errorMessage.startsWith('Python that comes with MacOS is not supported'), true, 'Error message that MacOS Python not supported not shown');
-    });
-
-    test('Mac: Default Python, Brew installation', async () => {
-        const c = new TestContext(true);
-        let errorMessage = '';
-        let processName = '';
-        let args;
-        let brewPath;
-        let outputShown = false;
-
-        c.appShell
-            .setup(x => x.showErrorMessage(TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString(), TypeMoq.It.isAnyString()))
-            .returns(() => Promise.resolve('Yes'));
-        c.appShell
-            .setup(x => x.showErrorMessage(TypeMoq.It.isAnyString()))
-            .callback((m: string) => errorMessage = m);
-        c.locator.setup(x => x.getInterpreters()).returns(() => Promise.resolve([]));
-        c.fileSystem
-            .setup(x => x.fileExistsAsync(TypeMoq.It.isAnyString()))
-            .returns((p: string) => {
-                brewPath = p;
-                return Promise.resolve(false);
-            });
-
-        const childProcess = TypeMoq.Mock.ofType<ChildProcess>();
-        childProcess
-            .setup(p => p.on('exit', TypeMoq.It.isAny()))
-            .callback((e: string, listener: (code, signal) => void) => {
-                listener.call(0, undefined);
-            });
-        const processOutput: Output<string> = {
-            source: 'stdout',
-            out: 'started'
-        };
-        const observable = new Rx.Observable<Output<string>>(subscriber => subscriber.next(processOutput));
-        const brewInstallProcess: ObservableExecutionResult<string> = {
-            proc: childProcess.object,
-            out: observable
-        };
-
-        c.output.setup(x => x.show()).callback(() => outputShown = true);
-        c.process
-            .setup(x => x.execObservable(TypeMoq.It.isAnyString(), TypeMoq.It.isAny(), TypeMoq.It.isAny()))
-            .callback((p: string, a: string[], o: SpawnOptions) => {
-                processName = p;
-                args = a;
-            })
-            .returns(() => brewInstallProcess);
-
-        await c.pythonInstaller.checkPythonInstallation(c.settings.object);
-
-        assert.notEqual(brewPath, undefined, 'Brew installer location not checked');
-        assert.equal(brewPath, '/usr/local/bin/brew', 'Brew installer location is incorrect');
-        assert.notEqual(processName, undefined, 'Brew installer not invoked');
-        assert.equal(processName, '/usr/bin/ruby', 'Brew installer name is incorrect');
-        assert.equal(args[0], '-e', 'Brew installer argument is incorrect');
-        assert.equal(args[1], '"$(curl -fsSL https://github.com/raw/Homebrew/install/master/install)"', 'Homebrew installer argument is incorrect');
-        assert.equal(outputShown, true, 'Output panel not shown');
-        assert.equal(errorMessage.startsWith('Unable to install Homebrew'), true, 'Homebrew install failed message no shown');
-
-        c.fileSystem
-            .setup(x => x.fileExistsAsync(TypeMoq.It.isAnyString()))
-            .returns(() => Promise.resolve(true));
-        errorMessage = '';
-
-        await c.pythonInstaller.checkPythonInstallation(c.settings.object);
-        assert.equal(errorMessage, '', `Unexpected error message ${errorMessage}`);
-        assert.equal(processName, 'brew', 'Brew installer name is incorrect');
-        assert.equal(args[0], 'install', 'Brew "install" argument is incorrect');
-        assert.equal(args[1], 'python', 'Brew "python" argument is incorrect');
-    });
 });