CoCalc -- extensionsScannerService.test.ts

GitHub Repository: microsoft/vscode
Path: blob/main/src/vs/platform/extensionManagement/test/node/extensionsScannerService.test.ts
³²⁹⁶ views
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
import assert from 'assert';
6
import { VSBuffer } from '../../../../base/common/buffer.js';
7
import { dirname, joinPath } from '../../../../base/common/resources.js';
8
import { URI } from '../../../../base/common/uri.js';
9
import { ensureNoDisposablesAreLeakedInTestSuite } from '../../../../base/test/common/utils.js';
10
import { INativeEnvironmentService } from '../../../environment/common/environment.js';
11
import { IExtensionsProfileScannerService, IProfileExtensionsScanOptions } from '../../common/extensionsProfileScannerService.js';
12
import { AbstractExtensionsScannerService, ExtensionScannerInput, IExtensionsScannerService, IScannedExtensionManifest, Translations } from '../../common/extensionsScannerService.js';
13
import { ExtensionsProfileScannerService } from '../../node/extensionsProfileScannerService.js';
14
import { ExtensionType, IExtensionManifest, TargetPlatform } from '../../../extensions/common/extensions.js';
15
import { IFileService } from '../../../files/common/files.js';
16
import { FileService } from '../../../files/common/fileService.js';
17
import { InMemoryFileSystemProvider } from '../../../files/common/inMemoryFilesystemProvider.js';
18
import { IInstantiationService } from '../../../instantiation/common/instantiation.js';
19
import { TestInstantiationService } from '../../../instantiation/test/common/instantiationServiceMock.js';
20
import { ILogService, NullLogService } from '../../../log/common/log.js';
21
import { IProductService } from '../../../product/common/productService.js';
22
import { IUriIdentityService } from '../../../uriIdentity/common/uriIdentity.js';
23
import { UriIdentityService } from '../../../uriIdentity/common/uriIdentityService.js';
24
import { IUserDataProfilesService, UserDataProfilesService } from '../../../userDataProfile/common/userDataProfile.js';
25

26
let translations: Translations = Object.create(null);
27
const ROOT = URI.file('/ROOT');
28

29
class ExtensionsScannerService extends AbstractExtensionsScannerService implements IExtensionsScannerService {
30

31
	constructor(
32
		@IUserDataProfilesService userDataProfilesService: IUserDataProfilesService,
33
		@IExtensionsProfileScannerService extensionsProfileScannerService: IExtensionsProfileScannerService,
34
		@IFileService fileService: IFileService,
35
		@ILogService logService: ILogService,
36
		@INativeEnvironmentService nativeEnvironmentService: INativeEnvironmentService,
37
		@IProductService productService: IProductService,
38
		@IUriIdentityService uriIdentityService: IUriIdentityService,
39
		@IInstantiationService instantiationService: IInstantiationService,
40
	) {
41
		super(
42
			URI.file(nativeEnvironmentService.builtinExtensionsPath),
43
			URI.file(nativeEnvironmentService.extensionsPath),
44
			joinPath(nativeEnvironmentService.userHome, '.vscode-oss-dev', 'extensions', 'control.json'),
45
			userDataProfilesService.defaultProfile,
46
			userDataProfilesService, extensionsProfileScannerService, fileService, logService, nativeEnvironmentService, productService, uriIdentityService, instantiationService);
47
	}
48

49
	protected async getTranslations(language: string): Promise<Translations> {
50
		return translations;
51
	}
52

53
}
54

55
suite('NativeExtensionsScanerService Test', () => {
56

57
	const disposables = ensureNoDisposablesAreLeakedInTestSuite();
58
	let instantiationService: TestInstantiationService;
59

60
	setup(async () => {
61
		translations = {};
62
		instantiationService = disposables.add(new TestInstantiationService());
63
		const logService = new NullLogService();
64
		const fileService = disposables.add(new FileService(logService));
65
		const fileSystemProvider = disposables.add(new InMemoryFileSystemProvider());
66
		disposables.add(fileService.registerProvider(ROOT.scheme, fileSystemProvider));
67
		instantiationService.stub(ILogService, logService);
68
		instantiationService.stub(IFileService, fileService);
69
		const systemExtensionsLocation = joinPath(ROOT, 'system');
70
		const userExtensionsLocation = joinPath(ROOT, 'extensions');
71
		const environmentService = instantiationService.stub(INativeEnvironmentService, {
72
			userHome: ROOT,
73
			userRoamingDataHome: ROOT,
74
			builtinExtensionsPath: systemExtensionsLocation.fsPath,
75
			extensionsPath: userExtensionsLocation.fsPath,
76
			cacheHome: joinPath(ROOT, 'cache'),
77
		});
78
		instantiationService.stub(IProductService, { version: '1.66.0' });
79
		const uriIdentityService = disposables.add(new UriIdentityService(fileService));
80
		instantiationService.stub(IUriIdentityService, uriIdentityService);
81
		const userDataProfilesService = disposables.add(new UserDataProfilesService(environmentService, fileService, uriIdentityService, logService));
82
		instantiationService.stub(IUserDataProfilesService, userDataProfilesService);
83
		instantiationService.stub(IExtensionsProfileScannerService, disposables.add(new ExtensionsProfileScannerService(environmentService, fileService, userDataProfilesService, uriIdentityService, logService)));
84
		await fileService.createFolder(systemExtensionsLocation);
85
		await fileService.createFolder(userExtensionsLocation);
86
	});
87

88
	test('scan system extension', async () => {
89
		const manifest: Partial<IExtensionManifest> = anExtensionManifest({ 'name': 'name', 'publisher': 'pub' });
90
		const extensionLocation = await aSystemExtension(manifest);
91
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
92

93
		const actual = await testObject.scanSystemExtensions({});
94

95
		assert.deepStrictEqual(actual.length, 1);
96
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
97
		assert.deepStrictEqual(actual[0].location.toString(), extensionLocation.toString());
98
		assert.deepStrictEqual(actual[0].isBuiltin, true);
99
		assert.deepStrictEqual(actual[0].type, ExtensionType.System);
100
		assert.deepStrictEqual(actual[0].isValid, true);
101
		assert.deepStrictEqual(actual[0].validations, []);
102
		assert.deepStrictEqual(actual[0].metadata, undefined);
103
		assert.deepStrictEqual(actual[0].targetPlatform, TargetPlatform.UNDEFINED);
104
		assert.deepStrictEqual(actual[0].manifest, manifest);
105
	});
106

107
	test('scan user extensions', async () => {
108
		const manifest: Partial<IScannedExtensionManifest> = anExtensionManifest({ 'name': 'name', 'publisher': 'pub' });
109
		const extensionLocation = await aUserExtension(manifest);
110
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
111

112
		const actual = await testObject.scanAllUserExtensions();
113

114
		assert.deepStrictEqual(actual.length, 1);
115
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
116
		assert.deepStrictEqual(actual[0].location.toString(), extensionLocation.toString());
117
		assert.deepStrictEqual(actual[0].isBuiltin, false);
118
		assert.deepStrictEqual(actual[0].type, ExtensionType.User);
119
		assert.deepStrictEqual(actual[0].isValid, true);
120
		assert.deepStrictEqual(actual[0].validations, []);
121
		assert.deepStrictEqual(actual[0].metadata, undefined);
122
		assert.deepStrictEqual(actual[0].targetPlatform, TargetPlatform.UNDEFINED);
123
		delete manifest.__metadata;
124
		assert.deepStrictEqual(actual[0].manifest, manifest);
125
	});
126

127
	test('scan existing extension', async () => {
128
		const manifest: Partial<IExtensionManifest> = anExtensionManifest({ 'name': 'name', 'publisher': 'pub' });
129
		const extensionLocation = await aUserExtension(manifest);
130
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
131

132
		const actual = await testObject.scanExistingExtension(extensionLocation, ExtensionType.User, {});
133

134
		assert.notEqual(actual, null);
135
		assert.deepStrictEqual(actual!.identifier, { id: 'pub.name' });
136
		assert.deepStrictEqual(actual!.location.toString(), extensionLocation.toString());
137
		assert.deepStrictEqual(actual!.isBuiltin, false);
138
		assert.deepStrictEqual(actual!.type, ExtensionType.User);
139
		assert.deepStrictEqual(actual!.isValid, true);
140
		assert.deepStrictEqual(actual!.validations, []);
141
		assert.deepStrictEqual(actual!.metadata, undefined);
142
		assert.deepStrictEqual(actual!.targetPlatform, TargetPlatform.UNDEFINED);
143
		assert.deepStrictEqual(actual!.manifest, manifest);
144
	});
145

146
	test('scan single extension', async () => {
147
		const manifest: Partial<IExtensionManifest> = anExtensionManifest({ 'name': 'name', 'publisher': 'pub' });
148
		const extensionLocation = await aUserExtension(manifest);
149
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
150

151
		const actual = await testObject.scanOneOrMultipleExtensions(extensionLocation, ExtensionType.User, {});
152

153
		assert.deepStrictEqual(actual.length, 1);
154
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
155
		assert.deepStrictEqual(actual[0].location.toString(), extensionLocation.toString());
156
		assert.deepStrictEqual(actual[0].isBuiltin, false);
157
		assert.deepStrictEqual(actual[0].type, ExtensionType.User);
158
		assert.deepStrictEqual(actual[0].isValid, true);
159
		assert.deepStrictEqual(actual[0].validations, []);
160
		assert.deepStrictEqual(actual[0].metadata, undefined);
161
		assert.deepStrictEqual(actual[0].targetPlatform, TargetPlatform.UNDEFINED);
162
		assert.deepStrictEqual(actual[0].manifest, manifest);
163
	});
164

165
	test('scan multiple extensions', async () => {
166
		const extensionLocation = await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub' }));
167
		await aUserExtension(anExtensionManifest({ 'name': 'name2', 'publisher': 'pub' }));
168
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
169

170
		const actual = await testObject.scanOneOrMultipleExtensions(dirname(extensionLocation), ExtensionType.User, {});
171

172
		assert.deepStrictEqual(actual.length, 2);
173
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
174
		assert.deepStrictEqual(actual[1].identifier, { id: 'pub.name2' });
175
	});
176

177
	test('scan all user extensions with different versions', async () => {
178
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.1' }));
179
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.2' }));
180
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
181

182
		const actual = await testObject.scanAllUserExtensions({ includeAllVersions: false, includeInvalid: false });
183

184
		assert.deepStrictEqual(actual.length, 1);
185
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
186
		assert.deepStrictEqual(actual[0].manifest.version, '1.0.2');
187
	});
188

189
	test('scan all user extensions include all versions', async () => {
190
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.1' }));
191
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.2' }));
192
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
193

194
		const actual = await testObject.scanAllUserExtensions();
195

196
		assert.deepStrictEqual(actual.length, 2);
197
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
198
		assert.deepStrictEqual(actual[0].manifest.version, '1.0.1');
199
		assert.deepStrictEqual(actual[1].identifier, { id: 'pub.name' });
200
		assert.deepStrictEqual(actual[1].manifest.version, '1.0.2');
201
	});
202

203
	test('scan all user extensions with different versions and higher version is not compatible', async () => {
204
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.1' }));
205
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.2', engines: { vscode: '^1.67.0' } }));
206
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
207

208
		const actual = await testObject.scanAllUserExtensions({ includeAllVersions: false, includeInvalid: false });
209

210
		assert.deepStrictEqual(actual.length, 1);
211
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
212
		assert.deepStrictEqual(actual[0].manifest.version, '1.0.1');
213
	});
214

215
	test('scan all user extensions exclude invalid extensions', async () => {
216
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub' }));
217
		await aUserExtension(anExtensionManifest({ 'name': 'name2', 'publisher': 'pub', engines: { vscode: '^1.67.0' } }));
218
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
219

220
		const actual = await testObject.scanAllUserExtensions({ includeAllVersions: false, includeInvalid: false });
221

222
		assert.deepStrictEqual(actual.length, 1);
223
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
224
	});
225

226
	test('scan all user extensions include invalid extensions', async () => {
227
		await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub' }));
228
		await aUserExtension(anExtensionManifest({ 'name': 'name2', 'publisher': 'pub', engines: { vscode: '^1.67.0' } }));
229
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
230

231
		const actual = await testObject.scanAllUserExtensions({ includeAllVersions: false, includeInvalid: true });
232

233
		assert.deepStrictEqual(actual.length, 2);
234
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
235
		assert.deepStrictEqual(actual[1].identifier, { id: 'pub.name2' });
236
	});
237

238
	test('scan system extensions include additional builtin extensions', async () => {
239
		instantiationService.stub(IProductService, {
240
			version: '1.66.0',
241
			builtInExtensions: [
242
				{ name: 'pub.name2', version: '', repo: '', metadata: undefined },
243
				{ name: 'pub.name', version: '', repo: '', metadata: undefined }
244
			]
245
		});
246
		await anExtension(anExtensionManifest({ 'name': 'name2', 'publisher': 'pub' }), joinPath(ROOT, 'additional'));
247
		const extensionLocation = await anExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub' }), joinPath(ROOT, 'additional'));
248
		await aSystemExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', version: '1.0.1' }));
249
		await instantiationService.get(IFileService).writeFile(joinPath(instantiationService.get(INativeEnvironmentService).userHome, '.vscode-oss-dev', 'extensions', 'control.json'), VSBuffer.fromString(JSON.stringify({ 'pub.name2': 'disabled', 'pub.name': extensionLocation.fsPath })));
250
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
251

252
		const actual = await testObject.scanSystemExtensions({ checkControlFile: true });
253

254
		assert.deepStrictEqual(actual.length, 1);
255
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
256
		assert.deepStrictEqual(actual[0].manifest.version, '1.0.0');
257
	});
258

259
	test('scan all user extensions with default nls replacements', async () => {
260
		const extensionLocation = await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', displayName: '%displayName%' }));
261
		await instantiationService.get(IFileService).writeFile(joinPath(extensionLocation, 'package.nls.json'), VSBuffer.fromString(JSON.stringify({ displayName: 'Hello World' })));
262
		const testObject = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
263

264
		const actual = await testObject.scanAllUserExtensions();
265

266
		assert.deepStrictEqual(actual.length, 1);
267
		assert.deepStrictEqual(actual[0].identifier, { id: 'pub.name' });
268
		assert.deepStrictEqual(actual[0].manifest.displayName, 'Hello World');
269
	});
270

271
	test('scan extension with en nls replacements', async () => {
272
		const extensionLocation = await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', displayName: '%displayName%' }));
273
		await instantiationService.get(IFileService).writeFile(joinPath(extensionLocation, 'package.nls.json'), VSBuffer.fromString(JSON.stringify({ displayName: 'Hello World' })));
274
		const nlsLocation = joinPath(extensionLocation, 'package.en.json');
275
		await instantiationService.get(IFileService).writeFile(nlsLocation, VSBuffer.fromString(JSON.stringify({ contents: { package: { displayName: 'Hello World EN' } } })));
276
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
277

278
		translations = { 'pub.name': nlsLocation.fsPath };
279
		const actual = await testObject.scanExistingExtension(extensionLocation, ExtensionType.User, { language: 'en' });
280

281
		assert.ok(actual !== null);
282
		assert.deepStrictEqual(actual!.identifier, { id: 'pub.name' });
283
		assert.deepStrictEqual(actual!.manifest.displayName, 'Hello World EN');
284
	});
285

286
	test('scan extension falls back to default nls replacements', async () => {
287
		const extensionLocation = await aUserExtension(anExtensionManifest({ 'name': 'name', 'publisher': 'pub', displayName: '%displayName%' }));
288
		await instantiationService.get(IFileService).writeFile(joinPath(extensionLocation, 'package.nls.json'), VSBuffer.fromString(JSON.stringify({ displayName: 'Hello World' })));
289
		const nlsLocation = joinPath(extensionLocation, 'package.en.json');
290
		await instantiationService.get(IFileService).writeFile(nlsLocation, VSBuffer.fromString(JSON.stringify({ contents: { package: { displayName: 'Hello World EN' } } })));
291
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
292

293
		translations = { 'pub.name2': nlsLocation.fsPath };
294
		const actual = await testObject.scanExistingExtension(extensionLocation, ExtensionType.User, { language: 'en' });
295

296
		assert.ok(actual !== null);
297
		assert.deepStrictEqual(actual!.identifier, { id: 'pub.name' });
298
		assert.deepStrictEqual(actual!.manifest.displayName, 'Hello World');
299
	});
300

301
	test('scan single extension with manifest metadata retains manifest metadata', async () => {
302
		const manifest: Partial<IExtensionManifest> = anExtensionManifest({ 'name': 'name', 'publisher': 'pub' });
303
		const expectedMetadata = { size: 12345, installedTimestamp: 1234567890, targetPlatform: TargetPlatform.DARWIN_ARM64 };
304
		const extensionLocation = await aUserExtension({
305
			...manifest,
306
			__metadata: expectedMetadata
307
		});
308
		const testObject: IExtensionsScannerService = disposables.add(instantiationService.createInstance(ExtensionsScannerService));
309

310
		const actual = await testObject.scanExistingExtension(extensionLocation, ExtensionType.User, {});
311

312
		assert.notStrictEqual(actual, null);
313
		assert.deepStrictEqual(actual!.identifier, { id: 'pub.name' });
314
		assert.deepStrictEqual(actual!.location.toString(), extensionLocation.toString());
315
		assert.deepStrictEqual(actual!.isBuiltin, false);
316
		assert.deepStrictEqual(actual!.type, ExtensionType.User);
317
		assert.deepStrictEqual(actual!.isValid, true);
318
		assert.deepStrictEqual(actual!.validations, []);
319
		assert.deepStrictEqual(actual!.metadata, expectedMetadata);
320
		assert.deepStrictEqual(actual!.manifest, manifest);
321
	});
322

323
	async function aUserExtension(manifest: Partial<IScannedExtensionManifest>): Promise<URI> {
324
		const environmentService = instantiationService.get(INativeEnvironmentService);
325
		return anExtension(manifest, URI.file(environmentService.extensionsPath));
326
	}
327

328
	async function aSystemExtension(manifest: Partial<IScannedExtensionManifest>): Promise<URI> {
329
		const environmentService = instantiationService.get(INativeEnvironmentService);
330
		return anExtension(manifest, URI.file(environmentService.builtinExtensionsPath));
331
	}
332

333
	async function anExtension(manifest: Partial<IScannedExtensionManifest>, root: URI): Promise<URI> {
334
		const fileService = instantiationService.get(IFileService);
335
		const extensionLocation = joinPath(root, `${manifest.publisher}.${manifest.name}-${manifest.version}`);
336
		await fileService.writeFile(joinPath(extensionLocation, 'package.json'), VSBuffer.fromString(JSON.stringify(manifest)));
337
		return extensionLocation;
338
	}
339

340
	function anExtensionManifest(manifest: Partial<IScannedExtensionManifest>): Partial<IExtensionManifest> {
341
		return { engines: { vscode: '^1.66.0' }, version: '1.0.0', main: 'main.js', activationEvents: ['*'], ...manifest };
342
	}
343
});
344

345
suite('ExtensionScannerInput', () => {
346

347
	ensureNoDisposablesAreLeakedInTestSuite();
348

349
	test('compare inputs - location', () => {
350
		const anInput = (location: URI, mtime: number | undefined) => new ExtensionScannerInput(location, mtime, undefined, undefined, false, undefined, ExtensionType.User, true, '1.1.1', undefined, undefined, true, undefined, {});
351

352
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, undefined), anInput(ROOT, undefined)), true);
353
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, 100), anInput(ROOT, 100)), true);
354
		assert.strictEqual(ExtensionScannerInput.equals(anInput(joinPath(ROOT, 'foo'), undefined), anInput(ROOT, undefined)), false);
355
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, 100), anInput(ROOT, 200)), false);
356
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, undefined), anInput(ROOT, 200)), false);
357
	});
358

359
	test('compare inputs - application location', () => {
360
		const anInput = (location: URI, mtime: number | undefined) => new ExtensionScannerInput(ROOT, undefined, location, mtime, false, undefined, ExtensionType.User, true, '1.1.1', undefined, undefined, true, undefined, {});
361

362
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, undefined), anInput(ROOT, undefined)), true);
363
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, 100), anInput(ROOT, 100)), true);
364
		assert.strictEqual(ExtensionScannerInput.equals(anInput(joinPath(ROOT, 'foo'), undefined), anInput(ROOT, undefined)), false);
365
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, 100), anInput(ROOT, 200)), false);
366
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ROOT, undefined), anInput(ROOT, 200)), false);
367
	});
368

369
	test('compare inputs - profile', () => {
370
		const anInput = (profile: boolean, profileScanOptions: IProfileExtensionsScanOptions | undefined) => new ExtensionScannerInput(ROOT, undefined, undefined, undefined, profile, profileScanOptions, ExtensionType.User, true, '1.1.1', undefined, undefined, true, undefined, {});
371

372
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, { bailOutWhenFileNotFound: true }), anInput(true, { bailOutWhenFileNotFound: true })), true);
373
		assert.strictEqual(ExtensionScannerInput.equals(anInput(false, { bailOutWhenFileNotFound: true }), anInput(false, { bailOutWhenFileNotFound: true })), true);
374
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, { bailOutWhenFileNotFound: false }), anInput(true, { bailOutWhenFileNotFound: false })), true);
375
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, {}), anInput(true, {})), true);
376
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, { bailOutWhenFileNotFound: true }), anInput(true, { bailOutWhenFileNotFound: false })), false);
377
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, {}), anInput(true, { bailOutWhenFileNotFound: true })), false);
378
		assert.strictEqual(ExtensionScannerInput.equals(anInput(true, undefined), anInput(true, {})), false);
379
		assert.strictEqual(ExtensionScannerInput.equals(anInput(false, { bailOutWhenFileNotFound: true }), anInput(true, { bailOutWhenFileNotFound: true })), false);
380
	});
381

382
	test('compare inputs - extension type', () => {
383
		const anInput = (type: ExtensionType) => new ExtensionScannerInput(ROOT, undefined, undefined, undefined, false, undefined, type, true, '1.1.1', undefined, undefined, true, undefined, {});
384

385
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ExtensionType.System), anInput(ExtensionType.System)), true);
386
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ExtensionType.User), anInput(ExtensionType.User)), true);
387
		assert.strictEqual(ExtensionScannerInput.equals(anInput(ExtensionType.User), anInput(ExtensionType.System)), false);
388
	});
389

390
});
391

392
Product

Resources

Company
