development/vscode
development/vscode
1
0
Fork 0
mirror of https://github.com/Microsoft/vscode synced 2024-09-19 18:48:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

fs - drop pfs.mkdirp in favor of node.js

Browse source
This commit is contained in:
Benjamin Pasero 2021-02-02 15:04:36 +01:00
parent ca746af08a
commit a0d76bb983
21 changed files with 70 additions and 72 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/vs/base/node/pfs.ts
View file

@ -288,10 +288,6 @@ export function readFile(path: string, encoding?: string): Promise<Buffer | stri
return promisify(fs.readFile)(path, encoding);
}
export async function mkdirp(path: string, mode?: number): Promise<void> {
return promisify(fs.mkdir)(path, { mode, recursive: true });
}
// According to node.js docs (https://nodejs.org/docs/v6.5.0/api/fs.html#fs_fs_writefile_file_data_options_callback)
// it is not safe to call writeFile() on the same path multiple times without waiting for the callback to return.
// Therefor we use a Queue on the path that is given to us to sequentialize calls to the same path properly.
@ -558,7 +554,7 @@ export async function copy(source: string, target: string, handledSourcesIn?: {
}
// Create folder
await mkdirp(target, stat.mode & COPY_MODE_MASK);
await fs.promises.mkdir(target, { recursive: true, mode: stat.mode & COPY_MODE_MASK });
// Copy each file recursively
const files = await readdir(source);

8
src/vs/base/node/zip.ts
View file

@ -5,10 +5,10 @@
import * as nls from 'vs/nls';
import * as path from 'vs/base/common/path';
import { createWriteStream, WriteStream } from 'fs';
import { promises, createWriteStream, WriteStream } from 'fs';
import { Readable } from 'stream';
import { Sequencer, createCancelablePromise } from 'vs/base/common/async';
import { mkdirp, rimraf } from 'vs/base/node/pfs';
import { rimraf } from 'vs/base/node/pfs';
import { open as _openZip, Entry, ZipFile } from 'yauzl';
import * as yazl from 'yazl';
import { CancellationToken } from 'vs/base/common/cancellation';
@ -86,7 +86,7 @@ function extractEntry(stream: Readable, fileName: string, mode: number, targetPa
}
});
return Promise.resolve(mkdirp(targetDirName)).then(() => new Promise<void>((c, e) => {
return Promise.resolve(promises.mkdir(targetDirName, { recursive: true })).then(() => new Promise<void>((c, e) => {
if (token.isCancellationRequested) {
return;
}
@ -149,7 +149,7 @@ function extractZip(zipfile: ZipFile, targetPath: string, options: IOptions, tok
// directory file names end with '/'
if (/\/$/.test(fileName)) {
const targetFileName = path.join(targetPath, fileName);
last = createCancelablePromise(token => mkdirp(targetFileName).then(() => readNextEntry(token)).then(undefined, e));
last = createCancelablePromise(token => promises.mkdir(targetFileName, { recursive: true }).then(() => readNextEntry(token)).then(undefined, e));
return;
}

7
src/vs/base/parts/storage/test/node/storage.test.ts
View file

@ -7,8 +7,9 @@ import { SQLiteStorageDatabase, ISQLiteStorageDatabaseOptions } from 'vs/base/pa
import { Storage, IStorageDatabase, IStorageItemsChangeEvent } from 'vs/base/parts/storage/common/storage';
import { join } from 'vs/base/common/path';
import { tmpdir } from 'os';
import { promises } from 'fs';
import { strictEqual, ok } from 'assert';
import { mkdirp, writeFile, exists, unlink, rimraf } from 'vs/base/node/pfs';
import { writeFile, exists, unlink, rimraf } from 'vs/base/node/pfs';
import { timeout } from 'vs/base/common/async';
import { Event, Emitter } from 'vs/base/common/event';
import { isWindows } from 'vs/base/common/platform';
@ -22,7 +23,7 @@ flakySuite('Storage Library', function () {
setup(function () {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'storagelibrary');
return mkdirp(testDir);
return promises.mkdir(testDir, { recursive: true });
});
teardown(function () {
@ -294,7 +295,7 @@ flakySuite('SQLite Storage Library', function () {
setup(function () {
testdir = getRandomTestPath(tmpdir(), 'vsctests', 'storagelibrary');
return mkdirp(testdir);
return promises.mkdir(testdir, { recursive: true });
});
teardown(function () {

5
src/vs/base/test/node/crypto.test.ts
View file

@ -6,7 +6,8 @@
import { checksum } from 'vs/base/node/crypto';
import { join } from 'vs/base/common/path';
import { tmpdir } from 'os';
import { mkdirp, rimraf, writeFile } from 'vs/base/node/pfs';
import { promises } from 'fs';
import { rimraf, writeFile } from 'vs/base/node/pfs';
import { getRandomTestPath } from 'vs/base/test/node/testUtils';
suite('Crypto', () => {
@ -16,7 +17,7 @@ suite('Crypto', () => {
setup(function () {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'crypto');
return mkdirp(testDir);
return promises.mkdir(testDir, { recursive: true });
});
teardown(function () {

5
src/vs/base/test/node/extpath.test.ts
View file

@ -5,7 +5,8 @@
import * as assert from 'assert';
import { tmpdir } from 'os';
import { mkdirp, rimraf } from 'vs/base/node/pfs';
import { promises } from 'fs';
import { rimraf } from 'vs/base/node/pfs';
import { realcaseSync, realpath, realpathSync } from 'vs/base/node/extpath';
import { flakySuite, getRandomTestPath } from 'vs/base/test/node/testUtils';
@ -15,7 +16,7 @@ flakySuite('Extpath', () => {
setup(() => {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'extpath');
return mkdirp(testDir, 493);
return promises.mkdir(testDir, { recursive: true });
});
teardown(() => {

22
src/vs/base/test/node/pfs/pfs.test.ts
View file

@ -8,7 +8,7 @@ import * as fs from 'fs';
import { tmpdir } from 'os';
import { join, sep } from 'vs/base/common/path';
import { generateUuid } from 'vs/base/common/uuid';
import { copy, exists, mkdirp, move, readdir, readDirsInDir, readdirWithFileTypes, readFile, renameIgnoreError, rimraf, RimRafMode, rimrafSync, statLink, writeFile, writeFileSync } from 'vs/base/node/pfs';
import { copy, exists, move, readdir, readDirsInDir, readdirWithFileTypes, readFile, renameIgnoreError, rimraf, RimRafMode, rimrafSync, statLink, writeFile, writeFileSync } from 'vs/base/node/pfs';
import { timeout } from 'vs/base/common/async';
import { getPathFromAmdModule } from 'vs/base/common/amd';
import { canNormalize } from 'vs/base/common/normalization';
@ -22,7 +22,7 @@ flakySuite('PFS', function () {
setup(() => {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'pfs');
return mkdirp(testDir, 493);
return fs.promises.mkdir(testDir, { recursive: true });
});
teardown(() => {
@ -204,7 +204,7 @@ flakySuite('PFS', function () {
const id3 = generateUuid();
const copyTarget = join(testDir, id3);
await mkdirp(symbolicLinkTarget, 493);
await fs.promises.mkdir(symbolicLinkTarget, { recursive: true });
fs.symlinkSync(symbolicLinkTarget, symbolicLink, 'junction');
@ -215,14 +215,6 @@ flakySuite('PFS', function () {
assert.ok(!fs.existsSync(copyTarget));
});
test('mkdirp', async () => {
const newDir = join(testDir, generateUuid());
await mkdirp(newDir, 493);
assert.ok(fs.existsSync(newDir));
});
test('readDirsInDir', async () => {
fs.mkdirSync(join(testDir, 'somefolder1'));
fs.mkdirSync(join(testDir, 'somefolder2'));
@ -244,7 +236,7 @@ flakySuite('PFS', function () {
const id2 = generateUuid();
const symbolicLink = join(testDir, id2);
await mkdirp(directory, 493);
await fs.promises.mkdir(directory, { recursive: true });
fs.symlinkSync(directory, symbolicLink, 'junction');
@ -263,7 +255,7 @@ flakySuite('PFS', function () {
const id2 = generateUuid();
const symbolicLink = join(testDir, id2);
await mkdirp(directory, 493);
await fs.promises.mkdir(directory, { recursive: true });
fs.symlinkSync(directory, symbolicLink, 'junction');
@ -279,7 +271,7 @@ flakySuite('PFS', function () {
const id = generateUuid();
const newDir = join(testDir, 'pfs', id, 'öäü');
await mkdirp(newDir, 493);
await fs.promises.mkdir(newDir, { recursive: true });
assert.ok(fs.existsSync(newDir));
@ -291,7 +283,7 @@ flakySuite('PFS', function () {
test('readdirWithFileTypes', async () => {
if (canNormalize && typeof process.versions['electron'] !== 'undefined' /* needs electron */) {
const newDir = join(testDir, 'öäü');
await mkdirp(newDir, 493);
await fs.promises.mkdir(newDir, { recursive: true });
await writeFile(join(testDir, 'somefile.txt'), 'contents');

5
src/vs/base/test/node/zip/zip.test.ts
View file

@ -6,8 +6,9 @@
import * as assert from 'assert';
import * as path from 'vs/base/common/path';
import { tmpdir } from 'os';
import { promises } from 'fs';
import { extract } from 'vs/base/node/zip';
import { rimraf, exists, mkdirp } from 'vs/base/node/pfs';
import { rimraf, exists } from 'vs/base/node/pfs';
import { getPathFromAmdModule } from 'vs/base/common/amd';
import { createCancelablePromise } from 'vs/base/common/async';
import { getRandomTestPath } from 'vs/base/test/node/testUtils';
@ -19,7 +20,7 @@ suite('Zip', () => {
setup(() => {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'zip');
return mkdirp(testDir);
return promises.mkdir(testDir, { recursive: true });
});
teardown(() => {

5
src/vs/code/electron-main/main.ts
View file

@ -5,13 +5,12 @@
import 'vs/platform/update/common/update.config.contribution';
import { app, dialog } from 'electron';
import { unlinkSync } from 'fs';
import { promises, unlinkSync } from 'fs';
import { localize } from 'vs/nls';
import { isWindows, IProcessEnvironment, isMacintosh } from 'vs/base/common/platform';
import product from 'vs/platform/product/common/product';
import { parseMainProcessArgv, addArg } from 'vs/platform/environment/node/argvHelper';
import { createWaitMarkerFile } from 'vs/platform/environment/node/waitMarkerFile';
import { mkdirp } from 'vs/base/node/pfs';
import { LifecycleMainService, ILifecycleMainService } from 'vs/platform/lifecycle/electron-main/lifecycleMainService';
import { createChannelSender } from 'vs/base/parts/ipc/common/ipc';
import { Server as NodeIPCServer, serve as nodeIPCServe, connect as nodeIPCConnect, XDG_RUNTIME_DIR } from 'vs/base/parts/ipc/node/ipc.net';
@ -186,7 +185,7 @@ class CodeMain {
environmentService.globalStorageHome.fsPath,
environmentService.workspaceStorageHome.fsPath,
environmentService.backupHome
].map((path): undefined | Promise<void> => path ? mkdirp(path) : undefined));
].map((path): undefined | Promise<void> => path ? promises.mkdir(path, { recursive: true }) : undefined));
// Configuration service
const configurationServiceInitialization = configurationService.initialize();

4
src/vs/code/node/cliProcessMain.ts
View file

@ -28,7 +28,7 @@ import { RequestService } from 'vs/platform/request/node/requestService';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { ConfigurationService } from 'vs/platform/configuration/common/configurationService';
import { AppInsightsAppender } from 'vs/platform/telemetry/node/appInsightsAppender';
import { mkdirp, writeFile } from 'vs/base/node/pfs';
import { writeFile } from 'vs/base/node/pfs';
import { IStateService } from 'vs/platform/state/node/state';
import { StateService } from 'vs/platform/state/node/stateService';
import { ILogService, getLogLevel, LogLevel, ConsoleLogService, MultiplexLogService } from 'vs/platform/log/common/log';
@ -99,7 +99,7 @@ class CliMain extends Disposable {
services.set(INativeEnvironmentService, environmentService);
// Init folders
await Promise.all([environmentService.appSettingsHome.fsPath, environmentService.extensionsPath].map(path => path ? mkdirp(path) : undefined));
await Promise.all([environmentService.appSettingsHome.fsPath, environmentService.extensionsPath].map(path => path ? fs.promises.mkdir(path, { recursive: true }) : undefined));
// Log
const logLevel = getLogLevel(environmentService);

6
src/vs/platform/backup/test/electron-main/backupMainService.test.ts
View file

@ -106,7 +106,7 @@ flakySuite('BackupMainService', () => {
environmentService = new EnvironmentMainService(parseArgs(process.argv, OPTIONS));
await pfs.mkdirp(backupHome);
await fs.promises.mkdir(backupHome, { recursive: true });
configService = new TestConfigurationService();
service = new class TestBackupMainService extends BackupMainService {
@ -669,8 +669,8 @@ flakySuite('BackupMainService', () => {
assert.strictEqual(((await service.getDirtyWorkspaces()).length), 0);
try {
await pfs.mkdirp(path.join(folderBackupPath, Schemas.file));
await pfs.mkdirp(path.join(workspaceBackupPath, Schemas.untitled));
await fs.promises.mkdir(path.join(folderBackupPath, Schemas.file), { recursive: true });
await fs.promises.mkdir(path.join(workspaceBackupPath, Schemas.untitled), { recursive: true });
} catch (error) {
// ignore - folder might exist already
}

5
src/vs/platform/state/test/node/state.test.ts
View file

@ -5,10 +5,11 @@
import * as assert from 'assert';
import { tmpdir } from 'os';
import { promises } from 'fs';
import { join } from 'vs/base/common/path';
import { flakySuite, getRandomTestPath } from 'vs/base/test/node/testUtils';
import { FileStorage } from 'vs/platform/state/node/stateService';
import { mkdirp, rimraf, writeFileSync } from 'vs/base/node/pfs';
import { rimraf, writeFileSync } from 'vs/base/node/pfs';
flakySuite('StateService', () => {
@ -17,7 +18,7 @@ flakySuite('StateService', () => {
setup(() => {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'stateservice');
return mkdirp(testDir);
return promises.mkdir(testDir, { recursive: true });
});
teardown(() => {

5
src/vs/platform/storage/node/storageService.ts
View file

@ -10,7 +10,8 @@ import { SQLiteStorageDatabase, ISQLiteStorageDatabaseLoggingOptions } from 'vs/
import { Storage, IStorageDatabase, IStorage, StorageHint } from 'vs/base/parts/storage/common/storage';
import { mark } from 'vs/base/common/performance';
import { join } from 'vs/base/common/path';
import { copy, exists, mkdirp, writeFile } from 'vs/base/node/pfs';
import { copy, exists, writeFile } from 'vs/base/node/pfs';
import { promises } from 'fs';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { isSingleFolderWorkspaceIdentifier, isWorkspaceIdentifier, IWorkspaceInitializationPayload } from 'vs/platform/workspaces/common/workspaces';
import { assertIsDefined } from 'vs/base/common/types';
@ -138,7 +139,7 @@ export class NativeStorageService extends AbstractStorageService {
return { path: workspaceStorageFolderPath, wasCreated: false };
}
await mkdirp(workspaceStorageFolderPath);
await promises.mkdir(workspaceStorageFolderPath, { recursive: true });
// Write metadata into folder
this.ensureWorkspaceStorageFolderMeta(payload);

5
src/vs/platform/storage/test/node/storageService.test.ts
View file

@ -7,7 +7,8 @@ import { strictEqual } from 'assert';
import { StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
import { NativeStorageService } from 'vs/platform/storage/node/storageService';
import { tmpdir } from 'os';
import { mkdirp, rimraf } from 'vs/base/node/pfs';
import { promises } from 'fs';
import { rimraf } from 'vs/base/node/pfs';
import { NullLogService } from 'vs/platform/log/common/log';
import { NativeEnvironmentService } from 'vs/platform/environment/node/environmentService';
import { parseArgs, OPTIONS } from 'vs/platform/environment/node/argv';
@ -22,7 +23,7 @@ flakySuite('NativeStorageService', function () {
setup(() => {
testDir = getRandomTestPath(tmpdir(), 'vsctests', 'storageservice');
return mkdirp(testDir);
return promises.mkdir(testDir, { recursive: true });
});
teardown(() => {

2
src/vs/platform/update/electron-main/updateService.win32.ts
View file

@ -56,7 +56,7 @@ export class Win32UpdateService extends AbstractUpdateService {
@memoize
get cachePath(): Promise<string> {
const result = path.join(tmpdir(), `vscode-update-${product.target}-${process.arch}`);
return pfs.mkdirp(result).then(() => result);
return fs.promises.mkdir(result, { recursive: true }).then(() => result);
}
constructor(

6
src/vs/platform/workspaces/electron-main/workspacesManagementMainService.ts
View file

@ -6,8 +6,8 @@
import { toWorkspaceFolders, IWorkspaceIdentifier, hasWorkspaceFileExtension, UNTITLED_WORKSPACE_NAME, IResolvedWorkspace, IStoredWorkspaceFolder, isStoredWorkspaceFolder, IWorkspaceFolderCreationData, IUntitledWorkspaceInfo, getStoredWorkspaceFolder, IEnterWorkspaceResult, isUntitledWorkspace, isWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier } from 'vs/platform/workspaces/common/workspaces';
import { IEnvironmentMainService } from 'vs/platform/environment/electron-main/environmentMainService';
import { join, dirname } from 'vs/base/common/path';
import { mkdirp, writeFile, rimrafSync, readdirSync, writeFileSync } from 'vs/base/node/pfs';
import { readFileSync, existsSync, mkdirSync, statSync, Stats } from 'fs';
import { writeFile, rimrafSync, readdirSync, writeFileSync } from 'vs/base/node/pfs';
import { promises, readFileSync, existsSync, mkdirSync, statSync, Stats } from 'fs';
import { isLinux, isMacintosh, isWindows } from 'vs/base/common/platform';
import { Event, Emitter } from 'vs/base/common/event';
import { ILogService } from 'vs/platform/log/common/log';
@ -140,7 +140,7 @@ export class WorkspacesManagementMainService extends Disposable implements IWork
const { workspace, storedWorkspace } = this.newUntitledWorkspace(folders, remoteAuthority);
const configPath = workspace.configPath.fsPath;
await mkdirp(dirname(configPath));
await promises.mkdir(dirname(configPath), { recursive: true });
await writeFile(configPath, JSON.stringify(storedWorkspace, null, '\t'));
return workspace;

2
src/vs/platform/workspaces/test/electron-main/workspacesManagementMainService.test.ts
View file

@ -99,7 +99,7 @@ suite('WorkspacesManagementMainService', () => {
service = new WorkspacesManagementMainService(environmentService, new NullLogService(), new TestBackupMainService(), new TestDialogMainService());
return pfs.mkdirp(untitledWorkspacesHomePath);
return fs.promises.mkdir(untitledWorkspacesHomePath, { recursive: true });
});
teardown(() => {

5
src/vs/workbench/api/node/extHostOutputService.ts
View file

@ -9,7 +9,8 @@ import { URI } from 'vs/base/common/uri';
import { join } from 'vs/base/common/path';
import { OutputAppender } from 'vs/workbench/services/output/node/outputAppender';
import { toLocalISOString } from 'vs/base/common/date';
import { dirExists, mkdirp } from 'vs/base/node/pfs';
import { dirExists } from 'vs/base/node/pfs';
import { promises } from 'fs';
import { AbstractExtHostOutputChannel, ExtHostPushOutputChannel, ExtHostOutputService, LazyOutputChannel } from 'vs/workbench/api/common/extHostOutput';
import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
import { IExtHostRpcService } from 'vs/workbench/api/common/extHostRpcService';
@ -87,7 +88,7 @@ export class ExtHostOutputService2 extends ExtHostOutputService {
const outputDirPath = join(this._logsLocation.fsPath, `output_logging_${toLocalISOString(new Date()).replace(/-|:|\.\d+Z$/g, '')}`);
const exists = await dirExists(outputDirPath);
if (!exists) {
await mkdirp(outputDirPath);
await promises.mkdir(outputDirPath, { recursive: true });
}
const fileName = `${this._namePool++}-${name.replace(/[\\/:\*\?"<>\|]/g, '')}`;
const file = URI.file(join(outputDirPath, `${fileName}.log`));

7
src/vs/workbench/contrib/backup/test/electron-browser/backupTracker.test.ts
View file

@ -6,8 +6,9 @@
import * as assert from 'assert';
import { isMacintosh, isWindows } from 'vs/base/common/platform';
import { tmpdir } from 'os';
import { promises } from 'fs';
import { join } from 'vs/base/common/path';
import { mkdirp, rimraf, writeFile } from 'vs/base/node/pfs';
import { rimraf, writeFile } from 'vs/base/node/pfs';
import { URI } from 'vs/base/common/uri';
import { flakySuite, getRandomTestPath } from 'vs/base/test/node/testUtils';
import { hashPath } from 'vs/workbench/services/backup/electron-browser/backupFileService';
@ -106,8 +107,8 @@ flakySuite('BackupTracker (native)', function () {
disposables.add(registerTestFileEditor());
await mkdirp(backupHome);
await mkdirp(workspaceBackupPath);
await promises.mkdir(backupHome, { recursive: true });
await promises.mkdir(workspaceBackupPath, { recursive: true });
return writeFile(workspacesJsonPath, '');
});

8
src/vs/workbench/services/backup/test/electron-browser/backupFileService.test.ts
View file

@ -7,9 +7,9 @@ import * as assert from 'assert';
import { isWindows } from 'vs/base/common/platform';
import { createHash } from 'crypto';
import { tmpdir } from 'os';
import { existsSync, readFileSync, writeFileSync } from 'fs';
import { promises, existsSync, readFileSync, writeFileSync } from 'fs';
import { dirname, join } from 'vs/base/common/path';
import { mkdirp, readdirSync, rimraf, writeFile } from 'vs/base/node/pfs';
import { readdirSync, rimraf, writeFile } from 'vs/base/node/pfs';
import { URI } from 'vs/base/common/uri';
import { BackupFilesModel } from 'vs/workbench/services/backup/common/backupFileService';
import { createTextBufferFactory } from 'vs/editor/common/model/textModel';
@ -140,7 +140,7 @@ suite('BackupFileService', () => {
service = new NodeTestBackupFileService(testDir, workspaceBackupPath);
await mkdirp(backupHome);
await promises.mkdir(backupHome, { recursive: true });
return writeFile(workspacesJsonPath, '');
});
@ -639,7 +639,7 @@ suite('BackupFileService', () => {
});
test('resolve', async () => {
await mkdirp(dirname(fooBackupPath));
await promises.mkdir(dirname(fooBackupPath), { recursive: true });
writeFileSync(fooBackupPath, 'foo');
const model = new BackupFilesModel(service.fileService);

3
src/vs/workbench/services/extensions/electron-browser/cachedExtensionScanner.ts
View file

@ -3,6 +3,7 @@
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as fs from 'fs';
import * as nls from 'vs/nls';
import * as path from 'vs/base/common/path';
import * as errors from 'vs/base/common/errors';
@ -164,7 +165,7 @@ export class CachedExtensionScanner {
const cacheFile = path.join(cacheFolder, cacheKey);
try {
await pfs.mkdirp(cacheFolder);
await fs.promises.mkdir(cacheFolder, { recursive: true });
} catch (err) {
// That's ok...
}

21
src/vs/workbench/services/telemetry/test/electron-browser/commonProperties.test.ts
View file

@ -2,14 +2,15 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as assert from 'assert';
import * as path from 'vs/base/common/path';
import * as os from 'os';
import * as fs from 'fs';
import { join } from 'vs/base/common/path';
import { release, tmpdir } from 'os';
import { resolveWorkbenchCommonProperties } from 'vs/workbench/services/telemetry/electron-sandbox/workbenchCommonProperties';
import { getRandomTestPath } from 'vs/base/test/node/testUtils';
import { IStorageService, StorageScope, InMemoryStorageService, StorageTarget } from 'vs/platform/storage/common/storage';
import { mkdirp, rimraf } from 'vs/base/node/pfs';
import { rimraf } from 'vs/base/node/pfs';
import { timeout } from 'vs/base/common/async';
import { IFileService } from 'vs/platform/files/common/files';
import { FileService } from 'vs/platform/files/common/fileService';
@ -18,8 +19,8 @@ import { Schemas } from 'vs/base/common/network';
import { DiskFileSystemProvider } from 'vs/platform/files/node/diskFileSystemProvider';
suite('Telemetry - common properties', function () {
const parentDir = getRandomTestPath(os.tmpdir(), 'vsctests', 'telemetryservice');
const installSource = path.join(parentDir, 'installSource');
const parentDir = getRandomTestPath(tmpdir(), 'vsctests', 'telemetryservice');
const installSource = join(parentDir, 'installSource');
const commit: string = (undefined)!;
const version: string = (undefined)!;
@ -43,9 +44,9 @@ suite('Telemetry - common properties', function () {
});
test('default', async function () {
await mkdirp(parentDir);
await fs.promises.mkdir(parentDir, { recursive: true });
fs.writeFileSync(installSource, 'my.install.source');
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, os.release(), commit, version, 'someMachineId', undefined, installSource);
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, release(), commit, version, 'someMachineId', undefined, installSource);
assert.ok('commitHash' in props);
assert.ok('sessionID' in props);
assert.ok('timestamp' in props);
@ -66,7 +67,7 @@ suite('Telemetry - common properties', function () {
assert.ok('common.instanceId' in props, 'instanceId');
assert.ok('common.machineId' in props, 'machineId');
fs.unlinkSync(installSource);
const props_1 = await resolveWorkbenchCommonProperties(testStorageService, testFileService, os.release(), commit, version, 'someMachineId', undefined, installSource);
const props_1 = await resolveWorkbenchCommonProperties(testStorageService, testFileService, release(), commit, version, 'someMachineId', undefined, installSource);
assert.ok(!('common.source' in props_1));
});
@ -74,14 +75,14 @@ suite('Telemetry - common properties', function () {
testStorageService.store('telemetry.lastSessionDate', new Date().toUTCString(), StorageScope.GLOBAL, StorageTarget.MACHINE);
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, os.release(), commit, version, 'someMachineId', undefined, installSource);
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, release(), commit, version, 'someMachineId', undefined, installSource);
assert.ok('common.lastSessionDate' in props); // conditional, see below
assert.ok('common.isNewSession' in props);
assert.equal(props['common.isNewSession'], 0);
});
test('values chance on ask', async function () {
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, os.release(), commit, version, 'someMachineId', undefined, installSource);
const props = await resolveWorkbenchCommonProperties(testStorageService, testFileService, release(), commit, version, 'someMachineId', undefined, installSource);
let value1 = props['common.sequence'];
let value2 = props['common.sequence'];
assert.ok(value1 !== value2, 'seq');