10276223911

Committed 07 Aug 2024 12:54AM UTC coverage: 41.724% (-0.002%) from 41.726%

Build # 10276223911

Build Type

Pull #25812

github

Committed by

web-flow

Commit Message

Merge 164c9b8ba into 0acb8dfc9

Pull Request Pull Request #25812: Fix SQL version determination logic for Fabric DW

Run Details

8803 of 25826 branches covered (34.09%)

Branch coverage included in aggregate %.

0 of 8 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

30728 of 68919 relevant lines covered (44.59%)

14.55 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

45.22

/extensions/notebook/src/dialog/configurePython/configurePythonWizard.ts

/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/

import * as nls from 'vscode-nls';
import * as azdata from 'azdata';
import { BasePage } from './basePage';
import { ConfigurePathPage } from './configurePathPage';
import { PickPackagesPage } from './pickPackagesPage';
import { JupyterServerInstallation, PythonPkgDetails, PythonInstallSettings } from '../../jupyter/jupyterServerInstallation';
import * as utils from '../../common/utils';
import { promises as fs } from 'fs';
import { Deferred } from '../../common/promise';
import { PythonPathLookup } from '../pythonPathLookup';

const localize = nls.loadMessageBundle();

export interface ConfigurePythonModel {
        kernelName: string;
        pythonLocation: string;
        pythonPathLookup: PythonPathLookup;
        packagesToInstall: PythonPkgDetails[];
        installation: JupyterServerInstallation;
}

export class ConfigurePythonWizard {
        private readonly InstallButtonText = localize('configurePython.okButtonText', "Install");
        public readonly InvalidLocationMsg = localize('configurePython.invalidLocationMsg', "The specified install location is invalid.");
        private readonly PythonNotFoundMsg = localize('configurePython.pythonNotFoundMsg', "No Python installation was found at the specified location.");

        private _wizard: azdata.window.Wizard;
        private model: ConfigurePythonModel;

        private _setupComplete: Deferred<void>;

        constructor(private jupyterInstallation: JupyterServerInstallation) {
                this._setupComplete = new Deferred<void>();
        }

        public get wizard(): azdata.window.Wizard {
                return this._wizard;
        }

        public get setupComplete(): Promise<void> {
                return this._setupComplete.promise;
        }

        public async start(kernelName?: string, rejectOnCancel?: boolean): Promise<void> {
                this.model = <ConfigurePythonModel>{
                        kernelName: kernelName,
                        pythonPathLookup: new PythonPathLookup(),
                        installation: this.jupyterInstallation,
                        pythonLocation: JupyterServerInstallation.getPythonPathSetting()
                };

                let pages: Map<number, BasePage> = new Map<number, BasePage>();

                let wizardTitle: string;
                if (kernelName) {
                        wizardTitle = localize('configurePython.wizardNameWithKernel', "Configure Python to run {0} kernel", kernelName);
                } else {
                        wizardTitle = localize('configurePython.wizardNameWithoutKernel', "Configure Python to run kernels");
                }
                this._wizard = azdata.window.createWizard(wizardTitle, 'ConfigurePythonWizard', 600);
                let page0 = azdata.window.createWizardPage(localize('configurePython.page0Name', "Configure Python Runtime"));
                let page1 = azdata.window.createWizardPage(localize('configurePython.page1Name', "Install Dependencies"));

                page0.registerContent(async (view) => {
                        let configurePathPage = new ConfigurePathPage(this, page0, this.model, view);
                        pages.set(0, configurePathPage);
                        await configurePathPage.initialize();
                        await configurePathPage.onPageEnter();
                });

                page1.registerContent(async (view) => {
                        let pickPackagesPage = new PickPackagesPage(this, page1, this.model, view);
                        pages.set(1, pickPackagesPage);
                        await pickPackagesPage.initialize();
                });

                this._wizard.doneButton.label = this.InstallButtonText;
                this._wizard.cancelButton.onClick(() => {
                        if (rejectOnCancel) {
                                this._setupComplete.reject(localize('configurePython.pythonInstallDeclined', "Python installation was declined."));
                        } else {
                                this._setupComplete.resolve();
                        }
                });

                this._wizard.onPageChanged(async info => {
                        let newPage = pages.get(info.newPage);
                        if (newPage) {
                                await newPage.onPageEnter();
                        }
                });

                this._wizard.registerNavigationValidator(async (info) => {
                        // The pages have not been registered yet
                        if (pages.size === 0) {
                                return false;
                        }
                        let lastPage = pages.get(info.lastPage);
                        let newPage = pages.get(info.newPage);

                        // Hit "next" on last page, so handle submit
                        let nextOnLastPage = !newPage && lastPage instanceof PickPackagesPage;
                        if (nextOnLastPage) {
                                return await this.handlePackageInstall();
                        }

                        if (lastPage) {
                                let pageValid = await lastPage.onPageLeave();
                                if (!pageValid) {
                                        return false;
                                }
                        }

                        this.clearStatusMessage();
                        return true;
                });

                this._wizard.generateScriptButton.hidden = true;
                this._wizard.pages = [page0, page1];
                await this._wizard.open();
        }

        public async close(): Promise<void> {
                await this._wizard.close();
        }

        public showInfoMessage(errorMsg: string) {
                this._wizard.message = <azdata.window.DialogMessage>{
                        text: errorMsg,
                        level: azdata.window.MessageLevel.Information
                };
        }

        public showErrorMessage(errorMsg: string) {
                this._wizard.message = <azdata.window.DialogMessage>{
                        text: errorMsg,
                        level: azdata.window.MessageLevel.Error
                };
        }

        public clearStatusMessage() {
                this._wizard.message = undefined;
        }

        private async handlePackageInstall(): Promise<boolean> {
                let pythonLocation = this.model.pythonLocation;
                try {
                        let isValid = await this.isFileValid(pythonLocation);
                        if (!isValid) {
                                return false;
                        }

                        let exePath = JupyterServerInstallation.getPythonExePath(pythonLocation);
                        let pythonExists = await utils.exists(exePath);
                        if (!pythonExists) {
                                this.showErrorMessage(this.PythonNotFoundMsg);
                                return false;
                        }
                } catch (err) {
                        this.showErrorMessage(utils.getErrorMessage(err));
                        return false;
                }

                // Don't wait on installation, since there's currently no Cancel functionality
                let installSettings: PythonInstallSettings = {
                        installPath: pythonLocation,
                        packages: this.model.packagesToInstall
                };
                this.jupyterInstallation.startInstallProcess(false, installSettings)
                        .then(() => {
                                this._setupComplete.resolve();
                        })
                        .catch(err => {
                                this._setupComplete.reject(utils.getErrorMessage(err));
                        });

                return true;
        }

        private async isFileValid(pythonLocation: string): Promise<boolean> {
                try {
                        const stats = await fs.stat(pythonLocation);
                        if (stats.isFile()) {
                                this.showErrorMessage(this.InvalidLocationMsg);
                                return false;
                        }
                } catch (err) {
                        // Ignore error if folder doesn't exist, since it will be
                        // created during installation
                        if (err.code !== 'ENOENT') {
                                this.showErrorMessage(err.message);
                                return false;
                        }
                }
                return true;
        }
}

1	/*---------------------------------------------------------------------------------------------
2	* Copyright (c) Microsoft Corporation. All rights reserved.
3	* Licensed under the MIT License. See License.txt in the project root for license information.
4	--------------------------------------------------------------------------------------------/
5
6	import * as nls from 'vscode-nls';	1✔
7	import * as azdata from 'azdata';	1✔
8	import { BasePage } from './basePage';
9	import { ConfigurePathPage } from './configurePathPage';	1✔
10	import { PickPackagesPage } from './pickPackagesPage';	1✔
11	import { JupyterServerInstallation, PythonPkgDetails, PythonInstallSettings } from '../../jupyter/jupyterServerInstallation';	1✔
12	import * as utils from '../../common/utils';	1✔
13	import { promises as fs } from 'fs';	1✔
14	import { Deferred } from '../../common/promise';	1✔
15	import { PythonPathLookup } from '../pythonPathLookup';	1✔
16
17	const localize = nls.loadMessageBundle();	1✔
18
19	export interface ConfigurePythonModel {
20	kernelName: string;
21	pythonLocation: string;
22	pythonPathLookup: PythonPathLookup;
23	packagesToInstall: PythonPkgDetails[];
24	installation: JupyterServerInstallation;
25	}
26
27	export class ConfigurePythonWizard {	1✔
28	private readonly InstallButtonText = localize('configurePython.okButtonText', "Install");	9✔
29	public readonly InvalidLocationMsg = localize('configurePython.invalidLocationMsg', "The specified install location is invalid.");	9✔
30	private readonly PythonNotFoundMsg = localize('configurePython.pythonNotFoundMsg', "No Python installation was found at the specified location.");	9✔
31
32	private _wizard: azdata.window.Wizard;
33	private model: ConfigurePythonModel;
34
35	private _setupComplete: Deferred<void>;
36
37	constructor(private jupyterInstallation: JupyterServerInstallation) {	9✔
38	this._setupComplete = new Deferred<void>();	9✔
39	}
40
41	public get wizard(): azdata.window.Wizard {
42	return this._wizard;	7✔
43	}
44
45	public get setupComplete(): Promise<void> {
46	return this._setupComplete.promise;	3✔
47	}
48
49	public async start(kernelName?: string, rejectOnCancel?: boolean): Promise<void> {
50	this.model = <ConfigurePythonModel>{	3✔
51	kernelName: kernelName,
52	pythonPathLookup: new PythonPathLookup(),
53	installation: this.jupyterInstallation,
54	pythonLocation: JupyterServerInstallation.getPythonPathSetting()
55	};
56
57	let pages: Map<number, BasePage> = new Map<number, BasePage>();	3✔
58
59	let wizardTitle: string;
60	if (kernelName) {	3!
61	wizardTitle = localize('configurePython.wizardNameWithKernel', "Configure Python to run {0} kernel", kernelName);	×
62	} else {
63	wizardTitle = localize('configurePython.wizardNameWithoutKernel', "Configure Python to run kernels");	3✔
64	}
65	this._wizard = azdata.window.createWizard(wizardTitle, 'ConfigurePythonWizard', 600);	3✔
66	let page0 = azdata.window.createWizardPage(localize('configurePython.page0Name', "Configure Python Runtime"));	3✔
67	let page1 = azdata.window.createWizardPage(localize('configurePython.page1Name', "Install Dependencies"));	3✔
68
69	page0.registerContent(async (view) => {	3✔
70	let configurePathPage = new ConfigurePathPage(this, page0, this.model, view);	3✔
71	pages.set(0, configurePathPage);	3✔
72	await configurePathPage.initialize();	3✔
UNCOV 73	await configurePathPage.onPageEnter();	×
74	});
75
76	page1.registerContent(async (view) => {	3✔
77	let pickPackagesPage = new PickPackagesPage(this, page1, this.model, view);	3✔
78	pages.set(1, pickPackagesPage);	3✔
79	await pickPackagesPage.initialize();	3✔
80	});
81
82	this._wizard.doneButton.label = this.InstallButtonText;	3✔
83	this._wizard.cancelButton.onClick(() => {	3✔
84	if (rejectOnCancel) {	3✔
85	this._setupComplete.reject(localize('configurePython.pythonInstallDeclined', "Python installation was declined."));	1✔
86	} else {
87	this._setupComplete.resolve();	2✔
88	}
89	});
90
91	this._wizard.onPageChanged(async info => {	3✔
92	let newPage = pages.get(info.newPage);	3✔
93	if (newPage) {	3!
94	await newPage.onPageEnter();	×
95	}
96	});
97
98	this._wizard.registerNavigationValidator(async (info) => {	3✔
99	// The pages have not been registered yet
100	if (pages.size === 0) {	×
101	return false;	×
102	}
103	let lastPage = pages.get(info.lastPage);	×
104	let newPage = pages.get(info.newPage);	×
105
106	// Hit "next" on last page, so handle submit
107	let nextOnLastPage = !newPage && lastPage instanceof PickPackagesPage;	×
108	if (nextOnLastPage) {	×
109	return await this.handlePackageInstall();	×
110	}
111
112	if (lastPage) {	×
113	let pageValid = await lastPage.onPageLeave();	×
114	if (!pageValid) {	×
115	return false;	×
116	}
117	}
118
119	this.clearStatusMessage();	×
120	return true;	×
121	});
122
123	this._wizard.generateScriptButton.hidden = true;	3✔
124	this._wizard.pages = [page0, page1];	3✔
125	await this._wizard.open();	3✔
126	}
127
128	public async close(): Promise<void> {
129	await this._wizard.close();	3✔
130	}
131
132	public showInfoMessage(errorMsg: string) {
133	this._wizard.message = <azdata.window.DialogMessage>{	×
134	text: errorMsg,
135	level: azdata.window.MessageLevel.Information
136	};
137	}
138
139	public showErrorMessage(errorMsg: string) {
140	this._wizard.message = <azdata.window.DialogMessage>{	1✔
141	text: errorMsg,
142	level: azdata.window.MessageLevel.Error
143	};
144	}
145
146	public clearStatusMessage() {
147	this._wizard.message = undefined;	1✔
148	}
149
150	private async handlePackageInstall(): Promise<boolean> {
151	let pythonLocation = this.model.pythonLocation;	×
152	try {	×
153	let isValid = await this.isFileValid(pythonLocation);	×
154	if (!isValid) {	×
155	return false;	×
156	}
157
158	let exePath = JupyterServerInstallation.getPythonExePath(pythonLocation);	×
159	let pythonExists = await utils.exists(exePath);	×
160	if (!pythonExists) {	×
161	this.showErrorMessage(this.PythonNotFoundMsg);	×
162	return false;	×
163	}
164	} catch (err) {
165	this.showErrorMessage(utils.getErrorMessage(err));	×
166	return false;	×
167	}
168
169	// Don't wait on installation, since there's currently no Cancel functionality
170	let installSettings: PythonInstallSettings = {	×
171	installPath: pythonLocation,
172	packages: this.model.packagesToInstall
173	};
174	this.jupyterInstallation.startInstallProcess(false, installSettings)	×
175	.then(() => {
176	this._setupComplete.resolve();	×
177	})
178	.catch(err => {
179	this._setupComplete.reject(utils.getErrorMessage(err));	×
180	});
181
182	return true;	×
183	}
184
185	private async isFileValid(pythonLocation: string): Promise<boolean> {
186	try {	×
187	const stats = await fs.stat(pythonLocation);	×
188	if (stats.isFile()) {	×
189	this.showErrorMessage(this.InvalidLocationMsg);	×
190	return false;	×
191	}
192	} catch (err) {
193	// Ignore error if folder doesn't exist, since it will be
194	// created during installation
195	if (err.code !== 'ENOENT') {	×
196	this.showErrorMessage(err.message);	×
197	return false;	×
198	}
199	}
200	return true;	×
201	}
202	}

microsoft / azuredatastudio / 10276223911

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous