ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-14 18:46:34 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898 (#15681)

Browse Source 
* Merge from vscode a348d103d1256a06a2c9b3f9b406298a9fef6898

* Fixes and cleanup

* Distro

* Fix hygiene yarn

* delete no yarn lock changes file

* Fix hygiene

* Fix layer check

* Fix CI

* Skip lib checks

* Remove tests deleted in vs code

* Fix tests

* Distro

* Fix tests and add removed extension point

* Skip failing notebook tests for now

* Disable broken tests and cleanup build folder

* Update yarn.lock and fix smoke tests

* Bump sqlite

* fix contributed actions and file spacing

* Fix user data path

* Update yarn.locks

Co-authored-by: ADS Merger <karlb@microsoft.com>
This commit is contained in:
Charles Gagnon
2021-06-17 08:17:11 -07:00
committed by GitHub
parent fdcb97c7f7
commit 3cb2f552a6
2582 changed files with 124827 additions and 87099 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/vs/platform/userDataSync/common/abstractSynchronizer.ts
View File

@@ -34,7 +34,7 @@ type SyncSourceClassification = {
source?: { classification: 'SystemMetaData', purpose: 'FeatureInsight', isMeasurement: true };
};
function isSyncData(thing: any): thing is ISyncData {
export function isSyncData(thing: any): thing is ISyncData {
if (thing
&& (thing.version !== undefined && typeof thing.version === 'number')
&& (thing.content !== undefined && typeof thing.content === 'string')) {
@@ -118,6 +118,7 @@ export abstract class AbstractSynchroniser extends Disposable {
readonly onDidChangeLocal: Event<void> = this._onDidChangeLocal.event;
protected readonly lastSyncResource: URI;
private hasSyncResourceStateVersionChanged: boolean = false;
protected readonly syncResourceLogLabel: string;
private syncHeaders: IHeaders = {};
@@ -566,8 +567,7 @@ export abstract class AbstractSynchroniser extends Disposable {
const machineId = await this.currentMachineIdPromise;
const isLastSyncFromCurrentMachine = !!remoteUserData.syncData?.machineId && remoteUserData.syncData.machineId === machineId;
// For preview, use remoteUserData if lastSyncUserData does not exists and last sync is from current machine
const lastSyncUserDataForPreview = lastSyncUserData === null && isLastSyncFromCurrentMachine ? remoteUserData : lastSyncUserData;
const lastSyncUserDataForPreview = lastSyncUserData === null && isLastSyncFromCurrentMachine && !this.hasSyncResourceStateVersionChanged ? remoteUserData : lastSyncUserData;
const resourcePreviewResults = await this.generateSyncPreview(remoteUserData, lastSyncUserDataForPreview, token);
const resourcePreviews: IEditableResourcePreview[] = [];
@@ -616,6 +616,14 @@ export abstract class AbstractSynchroniser extends Disposable {
try {
const content = await this.fileService.readFile(this.lastSyncResource);
const parsed = JSON.parse(content.value.toString());
const resourceSyncStateVersion = this.userDataSyncResourceEnablementService.getResourceSyncStateVersion(this.resource);
this.hasSyncResourceStateVersionChanged = parsed.version && resourceSyncStateVersion && parsed.version !== resourceSyncStateVersion;
if (this.hasSyncResourceStateVersionChanged) {
this.logService.info(`${this.syncResourceLogLabel}: Reset last sync state because last sync state version ${parsed.version} is not compatible with current sync state version ${resourceSyncStateVersion}.`);
await this.resetLocal();
return null;
}
const userData: IUserData = parsed as IUserData;
if (userData.content === null) {
return { ref: parsed.ref, syncData: null } as T;
@@ -637,7 +645,12 @@ export abstract class AbstractSynchroniser extends Disposable {
}
protected async updateLastSyncUserData(lastSyncRemoteUserData: IRemoteUserData, additionalProps: IStringDictionary<any> = {}): Promise<void> {
const lastSyncUserData: IUserData = { ref: lastSyncRemoteUserData.ref, content: lastSyncRemoteUserData.syncData ? JSON.stringify(lastSyncRemoteUserData.syncData) : null, ...additionalProps };
if (additionalProps['ref'] || additionalProps['content'] || additionalProps['version']) {
throw new Error('Cannot have core properties as additional');
}
const version = this.userDataSyncResourceEnablementService.getResourceSyncStateVersion(this.resource);
const lastSyncUserData = { ref: lastSyncRemoteUserData.ref, content: lastSyncRemoteUserData.syncData ? JSON.stringify(lastSyncRemoteUserData.syncData) : null, version, ...additionalProps };
await this.fileService.writeFile(this.lastSyncResource, VSBuffer.fromString(JSON.stringify(lastSyncUserData)));
}

12
src/vs/platform/userDataSync/common/extensionsStorageSync.ts
View File

@@ -3,10 +3,12 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { distinct } from 'vs/base/common/arrays';
import { Emitter, Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import { adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { IProductService } from 'vs/platform/product/common/productService';
import { IStorageService, IStorageValueChangeEvent, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
export interface IExtensionIdWithVersion {
@@ -51,6 +53,7 @@ export class ExtensionsStorageSyncService extends Disposable implements IExtensi
constructor(
@IStorageService private readonly storageService: IStorageService,
@IProductService private readonly productService: IProductService,
) {
super();
this.initialize();
@@ -92,7 +95,12 @@ export class ExtensionsStorageSyncService extends Disposable implements IExtensi
}
getKeysForSync(extensionIdWithVersion: IExtensionIdWithVersion): string[] | undefined {
const keysForSyncValue = this.storageService.get(ExtensionsStorageSyncService.toKey(extensionIdWithVersion), StorageScope.GLOBAL);
return keysForSyncValue ? JSON.parse(keysForSyncValue) : undefined;
const extensionKeysForSyncFromProduct = this.productService.extensionSyncedKeys?.[extensionIdWithVersion.id.toLowerCase()];
const extensionKeysForSyncFromStorageValue = this.storageService.get(ExtensionsStorageSyncService.toKey(extensionIdWithVersion), StorageScope.GLOBAL);
const extensionKeysForSyncFromStorage = extensionKeysForSyncFromStorageValue ? JSON.parse(extensionKeysForSyncFromStorageValue) : undefined;
return extensionKeysForSyncFromStorage && extensionKeysForSyncFromProduct
? distinct([...extensionKeysForSyncFromStorage, ...extensionKeysForSyncFromProduct])
: (extensionKeysForSyncFromStorage || extensionKeysForSyncFromProduct);
}
}

106
src/vs/platform/userDataSync/common/extensionsSync.ts
View File

@@ -74,12 +74,12 @@ async function parseAndMigrateExtensions(syncData: ISyncData, extensionManagemen
return extensions;
}
function getExtensionStorageState(publisher: string, name: string, storageService: IStorageService): IStringDictionary<any> {
export function getExtensionStorageState(publisher: string, name: string, storageService: IStorageService): IStringDictionary<any> {
const extensionStorageValue = storageService.get(getExtensionId(publisher, name) /* use the same id used in extension host */, StorageScope.GLOBAL) || '{}';
return JSON.parse(extensionStorageValue);
}
function storeExtensionStorageState(publisher: string, name: string, extensionState: IStringDictionary<any>, storageService: IStorageService): void {
export function storeExtensionStorageState(publisher: string, name: string, extensionState: IStringDictionary<any>, storageService: IStorageService): void {
storageService.store(getExtensionId(publisher, name) /* use the same id used in extension host */, JSON.stringify(extensionState), StorageScope.GLOBAL, StorageTarget.MACHINE);
}
@@ -95,7 +95,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
/* Version 5: Introduce extension state */
protected readonly version: number = 5;
protected isEnabled(): boolean { return super.isEnabled() && this.extensionGalleryService.isEnabled(); }
protected override isEnabled(): boolean { return super.isEnabled() && this.extensionGalleryService.isEnabled(); }
private readonly previewResource: URI = this.extUri.joinPath(this.syncPreviewFolder, 'extensions.json');
private readonly localResource: URI = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' });
private readonly remoteResource: URI = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' });
@@ -292,7 +292,7 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
return [{ resource: this.extUri.joinPath(uri, 'extensions.json'), comparableResource: ExtensionsSynchroniser.EXTENSIONS_DATA_URI }];
}
async resolveContent(uri: URI): Promise<string | null> {
override async resolveContent(uri: URI): Promise<string | null> {
if (this.extUri.isEqual(uri, ExtensionsSynchroniser.EXTENSIONS_DATA_URI)) {
const installedExtensions = await this.extensionManagementService.getInstalled();
const ignoredExtensions = this.ignoredExtensionsManagementService.getIgnoredExtensions(installedExtensions);
@@ -494,13 +494,17 @@ export class ExtensionsSynchroniser extends AbstractSynchroniser implements IUse
}
export class ExtensionsInitializer extends AbstractInitializer {
export interface IExtensionsInitializerPreviewResult {
readonly installedExtensions: ILocalExtension[];
readonly disabledExtensions: IExtensionIdentifier[];
readonly newExtensions: IExtensionIdentifier[];
readonly remoteExtensions: ISyncExtension[];
}
export abstract class AbstractExtensionsInitializer extends AbstractInitializer {
constructor(
@IExtensionManagementService private readonly extensionManagementService: IExtensionManagementService,
@IExtensionGalleryService private readonly galleryService: IExtensionGalleryService,
@IGlobalExtensionEnablementService private readonly extensionEnablementService: IGlobalExtensionEnablementService,
@IStorageService private readonly storageService: IStorageService,
@IExtensionManagementService protected readonly extensionManagementService: IExtensionManagementService,
@IIgnoredExtensionsManagementService private readonly ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
@IFileService fileService: IFileService,
@IEnvironmentService environmentService: IEnvironmentService,
@@ -509,90 +513,34 @@ export class ExtensionsInitializer extends AbstractInitializer {
super(SyncResource.Extensions, environmentService, logService, fileService);
}
async doInitialize(remoteUserData: IRemoteUserData): Promise<void> {
const remoteExtensions: ISyncExtension[] | null = remoteUserData.syncData ? await parseAndMigrateExtensions(remoteUserData.syncData, this.extensionManagementService) : null;
if (!remoteExtensions) {
this.logService.info('Skipping initializing extensions because remote extensions does not exist.');
return;
}
await this.initializeRemoteExtensions(remoteExtensions);
protected async parseExtensions(remoteUserData: IRemoteUserData): Promise<ISyncExtension[] | null> {
return remoteUserData.syncData ? await parseAndMigrateExtensions(remoteUserData.syncData, this.extensionManagementService) : null;
}
protected async initializeRemoteExtensions(remoteExtensions: ISyncExtension[]): Promise<ILocalExtension[]> {
const newlyEnabledExtensions: ILocalExtension[] = [];
const installedExtensions = await this.extensionManagementService.getInstalled();
const newExtensionsToSync = new Map<string, ISyncExtension>();
const installedExtensionsToSync: { syncExtension: ISyncExtension, installedExtension: ILocalExtension }[] = [];
const toInstall: { names: string[], uuids: string[] } = { names: [], uuids: [] };
const toDisable: IExtensionIdentifier[] = [];
protected generatePreview(remoteExtensions: ISyncExtension[], localExtensions: ILocalExtension[]): IExtensionsInitializerPreviewResult {
const installedExtensions: ILocalExtension[] = [];
const newExtensions: IExtensionIdentifier[] = [];
const disabledExtensions: IExtensionIdentifier[] = [];
for (const extension of remoteExtensions) {
if (this.ignoredExtensionsManagementService.hasToNeverSyncExtension(extension.identifier.id)) {
// Skip extension ignored to sync
continue;
}
const installedExtension = installedExtensions.find(i => areSameExtensions(i.identifier, extension.identifier));
const installedExtension = localExtensions.find(i => areSameExtensions(i.identifier, extension.identifier));
if (installedExtension) {
installedExtensionsToSync.push({ syncExtension: extension, installedExtension });
installedExtensions.push(installedExtension);
if (extension.disabled) {
toDisable.push(extension.identifier);
disabledExtensions.push(extension.identifier);
}
} else {
if (extension.installed) {
newExtensionsToSync.set(extension.identifier.id.toLowerCase(), extension);
if (extension.identifier.uuid) {
toInstall.uuids.push(extension.identifier.uuid);
} else {
toInstall.names.push(extension.identifier.id);
}
if (extension.disabled) {
toDisable.push(extension.identifier);
}
} else if (extension.installed) {
newExtensions.push(extension.identifier);
if (extension.disabled) {
disabledExtensions.push(extension.identifier);
}
}
}
// 1. Initialise already installed extensions state
for (const { syncExtension, installedExtension } of installedExtensionsToSync) {
if (syncExtension.state) {
const extensionState = getExtensionStorageState(installedExtension.manifest.publisher, installedExtension.manifest.name, this.storageService);
Object.keys(syncExtension.state).forEach(key => extensionState[key] = syncExtension.state![key]);
storeExtensionStorageState(installedExtension.manifest.publisher, installedExtension.manifest.name, extensionState, this.storageService);
}
}
// 2. Initialise extensions enablement
if (toDisable.length) {
for (const identifier of toDisable) {
this.logService.trace(`Disabling extension...`, identifier.id);
await this.extensionEnablementService.disableExtension(identifier);
this.logService.info(`Disabling extension`, identifier.id);
}
}
// 3. Install extensions
if (toInstall.names.length || toInstall.uuids.length) {
const galleryExtensions = (await this.galleryService.query({ ids: toInstall.uuids, names: toInstall.names, pageSize: toInstall.uuids.length + toInstall.names.length }, CancellationToken.None)).firstPage;
for (const galleryExtension of galleryExtensions) {
try {
const extensionToSync = newExtensionsToSync.get(galleryExtension.identifier.id.toLowerCase())!;
if (extensionToSync.state) {
storeExtensionStorageState(galleryExtension.publisher, galleryExtension.name, extensionToSync.state, this.storageService);
}
this.logService.trace(`Installing extension...`, galleryExtension.identifier.id);
const local = await this.extensionManagementService.installFromGallery(galleryExtension, { isMachineScoped: false } /* pass options to prevent install and sync dialog in web */);
if (!toDisable.some(identifier => areSameExtensions(identifier, galleryExtension.identifier))) {
newlyEnabledExtensions.push(local);
}
this.logService.info(`Installed extension.`, galleryExtension.identifier.id);
} catch (error) {
this.logService.error(error);
}
}
}
return newlyEnabledExtensions;
return { installedExtensions, newExtensions, disabledExtensions, remoteExtensions };
}
}

20
src/vs/platform/userDataSync/common/globalStateMerge.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import * as objects from 'vs/base/common/objects';
import { IStorageValue } from 'vs/platform/userDataSync/common/userDataSync';
import { IStorageValue, SYNC_SERVICE_URL_TYPE } from 'vs/platform/userDataSync/common/userDataSync';
import { IStringDictionary } from 'vs/base/common/collections';
import { ILogService } from 'vs/platform/log/common/log';
@@ -30,15 +30,17 @@ export function merge(localStorage: IStringDictionary<IStorageValue>, remoteStor
const local: { added: IStringDictionary<IStorageValue>, removed: string[], updated: IStringDictionary<IStorageValue> } = { added: {}, removed: [], updated: {} };
const remote: IStringDictionary<IStorageValue> = objects.deepClone(remoteStorage);
const isFirstTimeSync = !baseStorage;
// Added in local
for (const key of baseToLocal.added.values()) {
// Skip if local was not synced before and remote also has the key
// In this case, remote gets precedence
if (!baseStorage && baseToRemote.added.has(key)) {
// If syncing for first time remote value gets precedence always,
// except for sync service type key - local value takes precedence for this key
if (key !== SYNC_SERVICE_URL_TYPE && isFirstTimeSync && baseToRemote.added.has(key)) {
continue;
} else {
remote[key] = localStorage[key];
}
remote[key] = localStorage[key];
}
// Updated in local
@@ -70,6 +72,12 @@ export function merge(localStorage: IStringDictionary<IStorageValue>, remoteStor
if (localValue && localValue.value === remoteValue.value) {
continue;
}
// Local sync service type value takes precedence if syncing for first time
if (key === SYNC_SERVICE_URL_TYPE && isFirstTimeSync && baseToLocal.added.has(key)) {
continue;
}
if (localValue) {
local.updated[key] = remoteValue;
} else {

113
src/vs/platform/userDataSync/common/globalStateSync.ts
View File

@@ -5,7 +5,7 @@
import {
IUserDataSyncStoreService, IUserDataSyncLogService, IGlobalState, SyncResource, IUserDataSynchroniser, IUserDataSyncResourceEnablementService,
IUserDataSyncBackupStoreService, ISyncResourceHandle, IStorageValue, USER_DATA_SYNC_SCHEME, IRemoteUserData, Change
IUserDataSyncBackupStoreService, ISyncResourceHandle, IStorageValue, USER_DATA_SYNC_SCHEME, IRemoteUserData, Change, ALL_SYNC_RESOURCES, getEnablementKey, SYNC_SERVICE_URL_TYPE, UserDataSyncStoreType, IUserData, ISyncData, createSyncHeaders, UserDataSyncError, UserDataSyncErrorCode
} from 'vs/platform/userDataSync/common/userDataSync';
import { VSBuffer } from 'vs/base/common/buffer';
import { Event } from 'vs/base/common/event';
@@ -15,7 +15,7 @@ import { IStringDictionary } from 'vs/base/common/collections';
import { edit } from 'vs/platform/userDataSync/common/content';
import { merge } from 'vs/platform/userDataSync/common/globalStateMerge';
import { parse } from 'vs/base/common/json';
import { AbstractInitializer, AbstractSynchroniser, IAcceptResult, IMergeResult, IResourcePreview } from 'vs/platform/userDataSync/common/abstractSynchronizer';
import { AbstractInitializer, AbstractSynchroniser, IAcceptResult, IMergeResult, IResourcePreview, isSyncData } from 'vs/platform/userDataSync/common/abstractSynchronizer';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { URI } from 'vs/base/common/uri';
@@ -23,6 +23,12 @@ import { format } from 'vs/base/common/jsonFormatter';
import { applyEdits } from 'vs/base/common/jsonEdit';
import { IStorageService, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
import { CancellationToken } from 'vs/base/common/cancellation';
import { isWeb } from 'vs/base/common/platform';
import { UserDataSyncStoreClient } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
import { getServiceMachineId } from 'vs/platform/serviceMachineId/common/serviceMachineId';
import { generateUuid } from 'vs/base/common/uuid';
import { IHeaders } from 'vs/base/parts/request/common/request';
import { ILogService } from 'vs/platform/log/common/log';
const argvStoragePrefx = 'globalState.argv.';
const argvProperties: string[] = ['locale'];
@@ -40,6 +46,18 @@ export interface IGlobalStateResourcePreview extends IResourcePreview {
readonly storageKeys: StorageKeys;
}
function formatAndStringify(globalState: IGlobalState): string {
const storageKeys = globalState.storage ? Object.keys(globalState.storage).sort() : [];
const storage: IStringDictionary<IStorageValue> = {};
storageKeys.forEach(key => storage[key] = globalState.storage[key]);
globalState.storage = storage;
const content = JSON.stringify(globalState);
const edits = format(content, undefined, {});
return applyEdits(content, edits);
}
const GLOBAL_STATE_DATA_VERSION = 1;
/**
* Synchronises global state that includes
* - Global storage with user scope
@@ -52,7 +70,7 @@ export interface IGlobalStateResourcePreview extends IResourcePreview {
export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUserDataSynchroniser {
private static readonly GLOBAL_STATE_DATA_URI = URI.from({ scheme: USER_DATA_SYNC_SCHEME, authority: 'globalState', path: `/globalState.json` });
protected readonly version: number = 1;
protected readonly version: number = GLOBAL_STATE_DATA_VERSION;
private readonly previewResource: URI = this.extUri.joinPath(this.syncPreviewFolder, 'globalState.json');
private readonly localResource: URI = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' });
private readonly remoteResource: URI = this.previewResource.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' });
@@ -63,7 +81,7 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
@IUserDataSyncBackupStoreService userDataSyncBackupStoreService: IUserDataSyncBackupStoreService,
@IUserDataSyncLogService logService: IUserDataSyncLogService,
@IEnvironmentService readonly environmentService: IEnvironmentService,
@IEnvironmentService environmentService: IEnvironmentService,
@IUserDataSyncResourceEnablementService userDataSyncResourceEnablementService: IUserDataSyncResourceEnablementService,
@ITelemetryService telemetryService: ITelemetryService,
@IConfigurationService configurationService: IConfigurationService,
@@ -107,10 +125,10 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
return [{
localResource: this.localResource,
localContent: this.format(localGloablState),
localContent: formatAndStringify(localGloablState),
localUserData: localGloablState,
remoteResource: this.remoteResource,
remoteContent: remoteGlobalState ? this.format(remoteGlobalState) : null,
remoteContent: remoteGlobalState ? formatAndStringify(remoteGlobalState) : null,
previewResource: this.previewResource,
previewResult,
localChange: previewResult.localChange,
@@ -212,10 +230,10 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
return [{ resource: this.extUri.joinPath(uri, 'globalState.json'), comparableResource: GlobalStateSynchroniser.GLOBAL_STATE_DATA_URI }];
}
async resolveContent(uri: URI): Promise<string | null> {
override async resolveContent(uri: URI): Promise<string | null> {
if (this.extUri.isEqual(uri, GlobalStateSynchroniser.GLOBAL_STATE_DATA_URI)) {
const localGlobalState = await this.getLocalGlobalState();
return this.format(localGlobalState);
return formatAndStringify(localGlobalState);
}
if (this.extUri.isEqual(this.remoteResource, uri) || this.extUri.isEqual(this.localResource, uri) || this.extUri.isEqual(this.acceptedResource, uri)) {
@@ -233,7 +251,7 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
if (syncData) {
switch (this.extUri.basename(uri)) {
case 'globalState.json':
return this.format(JSON.parse(syncData.content));
return formatAndStringify(JSON.parse(syncData.content));
}
}
}
@@ -241,16 +259,6 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
return null;
}
private format(globalState: IGlobalState): string {
const storageKeys = globalState.storage ? Object.keys(globalState.storage).sort() : [];
const storage: IStringDictionary<IStorageValue> = {};
storageKeys.forEach(key => storage[key] = globalState.storage[key]);
globalState.storage = storage;
const content = JSON.stringify(globalState);
const edits = format(content, undefined, {});
return applyEdits(content, edits);
}
async hasLocalData(): Promise<boolean> {
try {
const { storage } = await this.getLocalGlobalState();
@@ -346,6 +354,14 @@ export class GlobalStateSynchroniser extends AbstractSynchroniser implements IUs
const machine = this.storageService.keys(StorageScope.GLOBAL, StorageTarget.MACHINE);
const registered = [...user, ...machine];
const unregistered = lastSyncGlobalState?.storage ? Object.keys(lastSyncGlobalState.storage).filter(key => !key.startsWith(argvStoragePrefx) && !registered.includes(key) && this.storageService.get(key, StorageScope.GLOBAL) !== undefined) : [];
if (!isWeb) {
// Following keys are synced only in web. Do not sync these keys in other platforms
const keysSyncedOnlyInWeb = [...ALL_SYNC_RESOURCES.map(resource => getEnablementKey(resource)), SYNC_SERVICE_URL_TYPE];
unregistered.push(...keysSyncedOnlyInWeb);
machine.push(...keysSyncedOnlyInWeb);
}
return { user, machine, unregistered };
}
}
@@ -401,3 +417,62 @@ export class GlobalStateInitializer extends AbstractInitializer {
}
export class UserDataSyncStoreTypeSynchronizer {
constructor(
private readonly userDataSyncStoreClient: UserDataSyncStoreClient,
@IStorageService private readonly storageService: IStorageService,
@IEnvironmentService private readonly environmentService: IEnvironmentService,
@IFileService private readonly fileService: IFileService,
@ILogService private readonly logService: ILogService,
) {
}
getSyncStoreType(userData: IUserData): UserDataSyncStoreType | undefined {
const remoteGlobalState = this.parseGlobalState(userData);
return remoteGlobalState?.storage[SYNC_SERVICE_URL_TYPE]?.value as UserDataSyncStoreType;
}
async sync(userDataSyncStoreType: UserDataSyncStoreType): Promise<void> {
const syncHeaders = createSyncHeaders(generateUuid());
try {
return await this.doSync(userDataSyncStoreType, syncHeaders);
} catch (e) {
if (e instanceof UserDataSyncError) {
switch (e.code) {
case UserDataSyncErrorCode.PreconditionFailed:
this.logService.info(`Failed to synchronize UserDataSyncStoreType as there is a new remote version available. Synchronizing again...`);
return this.doSync(userDataSyncStoreType, syncHeaders);
}
}
throw e;
}
}
private async doSync(userDataSyncStoreType: UserDataSyncStoreType, syncHeaders: IHeaders): Promise<void> {
// Read the global state from remote
const globalStateUserData = await this.userDataSyncStoreClient.read(SyncResource.GlobalState, null, syncHeaders);
const remoteGlobalState = this.parseGlobalState(globalStateUserData) || { storage: {} };
// Update the sync store type
remoteGlobalState.storage[SYNC_SERVICE_URL_TYPE] = { value: userDataSyncStoreType, version: GLOBAL_STATE_DATA_VERSION };
// Write the global state to remote
const machineId = await getServiceMachineId(this.environmentService, this.fileService, this.storageService);
const syncDataToUpdate: ISyncData = { version: GLOBAL_STATE_DATA_VERSION, machineId, content: formatAndStringify(remoteGlobalState) };
await this.userDataSyncStoreClient.write(SyncResource.GlobalState, JSON.stringify(syncDataToUpdate), globalStateUserData.ref, syncHeaders);
}
private parseGlobalState({ content }: IUserData): IGlobalState | null {
if (!content) {
return null;
}
const syncData = JSON.parse(content);
if (isSyncData(syncData)) {
return syncData ? JSON.parse(syncData.content) : null;
}
throw new Error('Invalid remote data');
}
}

2
src/vs/platform/userDataSync/common/keybindingsSync.ts
View File

@@ -258,7 +258,7 @@ export class KeybindingsSynchroniser extends AbstractJsonFileSynchroniser implem
return [{ resource: this.extUri.joinPath(uri, 'keybindings.json'), comparableResource }];
}
async resolveContent(uri: URI): Promise<string | null> {
override async resolveContent(uri: URI): Promise<string | null> {
if (this.extUri.isEqual(this.remoteResource, uri) || this.extUri.isEqual(this.localResource, uri) || this.extUri.isEqual(this.acceptedResource, uri)) {
return this.resolvePreviewContent(uri);
}

4
src/vs/platform/userDataSync/common/settingsSync.ts
View File

@@ -247,7 +247,7 @@ export class SettingsSynchroniser extends AbstractJsonFileSynchroniser implement
return [{ resource: this.extUri.joinPath(uri, 'settings.json'), comparableResource }];
}
async resolveContent(uri: URI): Promise<string | null> {
override async resolveContent(uri: URI): Promise<string | null> {
if (this.extUri.isEqual(this.remoteResource, uri) || this.extUri.isEqual(this.localResource, uri) || this.extUri.isEqual(this.acceptedResource, uri)) {
return this.resolvePreviewContent(uri);
}
@@ -271,7 +271,7 @@ export class SettingsSynchroniser extends AbstractJsonFileSynchroniser implement
return null;
}
protected async resolvePreviewContent(resource: URI): Promise<string | null> {
protected override async resolvePreviewContent(resource: URI): Promise<string | null> {
let content = await super.resolvePreviewContent(resource);
if (content) {
const formatUtils = await this.getFormattingOptions();

2
src/vs/platform/userDataSync/common/snippetsSync.ts
View File

@@ -355,7 +355,7 @@ export class SnippetsSynchroniser extends AbstractSynchroniser implements IUserD
return [];
}
async resolveContent(uri: URI): Promise<string | null> {
override async resolveContent(uri: URI): Promise<string | null> {
if (this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'remote' }))
|| this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'local' }))
|| this.extUri.isEqualOrParent(uri, this.syncPreviewFolder.with({ scheme: USER_DATA_SYNC_SCHEME, authority: 'accepted' }))) {

46
src/vs/platform/userDataSync/common/userDataAutoSyncService.ts
View File

@@ -18,6 +18,8 @@ import { localize } from 'vs/nls';
import { toLocalISOString } from 'vs/base/common/date';
import { URI } from 'vs/base/common/uri';
import { isEqual } from 'vs/base/common/resources';
import { isWeb } from 'vs/base/common/platform';
import { IProductService } from 'vs/platform/product/common/productService';
type AutoSyncClassification = {
sources: { classification: 'SystemMetaData', purpose: 'FeatureInsight', isMeasurement: true };
@@ -36,6 +38,7 @@ const enablementKey = 'sync.enable';
const disableMachineEventuallyKey = 'sync.disableMachineEventually';
const sessionIdKey = 'sync.sessionId';
const storeUrlKey = 'sync.storeUrl';
const productQualityKey = 'sync.productQuality';
interface _IUserDataAutoSyncEnablementService extends IUserDataAutoSyncEnablementService {
canToggleEnablement(): boolean;
@@ -76,6 +79,9 @@ export class UserDataAutoSyncEnablementService extends Disposable implements _IU
}
setEnablement(enabled: boolean): void {
if (enabled && !this.canToggleEnablement()) {
return;
}
this.storageService.store(enablementKey, enabled, StorageScope.GLOBAL, StorageTarget.MACHINE);
}
@@ -119,7 +125,20 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
}
}
private previousProductQuality: string | undefined;
private get productQuality(): string | undefined {
return this.storageService.get(productQualityKey, StorageScope.GLOBAL);
}
private set productQuality(productQuality: string | undefined) {
if (productQuality) {
this.storageService.store(productQualityKey, productQuality, StorageScope.GLOBAL, StorageTarget.MACHINE);
} else {
this.storageService.remove(productQualityKey, StorageScope.GLOBAL);
}
}
constructor(
@IProductService productService: IProductService,
@IUserDataSyncStoreManagementService private readonly userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
@IUserDataSyncStoreService private readonly userDataSyncStoreService: IUserDataSyncStoreService,
@IUserDataSyncResourceEnablementService private readonly userDataSyncResourceEnablementService: IUserDataSyncResourceEnablementService,
@@ -138,6 +157,9 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
this.lastSyncUrl = this.syncUrl;
this.syncUrl = userDataSyncStoreManagementService.userDataSyncStore?.url;
this.previousProductQuality = this.productQuality;
this.productQuality = productService.quality;
if (this.syncUrl) {
this.logService.info('Using settings sync service', this.syncUrl.toString());
@@ -166,6 +188,7 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
this._register(userDataSyncStoreService.onDidChangeDonotMakeRequestsUntil(() => this.updateAutoSync()));
this._register(Event.debounce<string, string[]>(userDataSyncService.onDidChangeLocal, (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, false, false)));
this._register(Event.filter(this.userDataSyncResourceEnablementService.onDidChangeResourceEnablement, ([, enabled]) => enabled)(() => this.triggerSync(['resourceEnablement'], false, false)));
this._register(this.userDataSyncStoreManagementService.onDidChangeUserDataSyncStore(() => this.triggerSync(['userDataSyncStoreChanged'], false, false)));
}
}
@@ -257,6 +280,10 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
}
}
private hasProductQualityChanged(): boolean {
return !!this.previousProductQuality && !!this.productQuality && this.previousProductQuality !== this.productQuality;
}
private async onDidFinishSync(error: Error | undefined): Promise<void> {
if (!error) {
// Sync finished without errors
@@ -314,9 +341,22 @@ export class UserDataAutoSyncService extends Disposable implements IUserDataAuto
// Service changed
else if (userDataSyncError.code === UserDataSyncErrorCode.ServiceChanged || userDataSyncError.code === UserDataSyncErrorCode.DefaultServiceChanged) {
await this.turnOff(false, true /* force soft turnoff on error */, true /* do not disable machine */);
await this.turnOn();
this.logService.info('Auto Sync: Sync Service changed. Turned off auto sync, reset local state and turned on auto sync.');
// Check if default settings sync service has changed in web without changing the product quality
// Then turn off settings sync and ask user to turn on again
if (isWeb && userDataSyncError.code === UserDataSyncErrorCode.DefaultServiceChanged && !this.hasProductQualityChanged()) {
await this.turnOff(false, true /* force soft turnoff on error */);
this.logService.info('Auto Sync: Turned off sync because default sync service is changed.');
}
// Service has changed by the user. So turn off and turn on sync.
// Show a prompt to the user about service change.
else {
await this.turnOff(false, true /* force soft turnoff on error */, true /* do not disable machine */);
await this.turnOn();
this.logService.info('Auto Sync: Sync Service changed. Turned off auto sync, reset local state and turned on auto sync.');
}
}
else {

18
src/vs/platform/userDataSync/common/userDataSync.ts
View File

@@ -108,6 +108,7 @@ export type IAuthenticationProvider = { id: string, scopes: string[] };
export interface IUserDataSyncStore {
readonly url: URI;
readonly type: UserDataSyncStoreType;
readonly defaultUrl: URI;
readonly stableUrl: URI;
readonly insidersUrl: URI;
@@ -192,6 +193,12 @@ export interface IUserDataSyncBackupStoreService {
export const HEADER_OPERATION_ID = 'x-operation-id';
export const HEADER_EXECUTION_ID = 'X-Execution-Id';
export function createSyncHeaders(executionId: string): IHeaders {
const headers: IHeaders = {};
headers[HEADER_EXECUTION_ID] = executionId;
return headers;
}
//#endregion
// #region User Data Sync Error
@@ -243,7 +250,7 @@ export class UserDataSyncError extends Error {
}
export class UserDataSyncStoreError extends UserDataSyncError {
constructor(message: string, readonly url: string, code: UserDataSyncErrorCode, readonly operationId: string | undefined) {
constructor(message: string, readonly url: string, code: UserDataSyncErrorCode, operationId: string | undefined) {
super(message, code, undefined, operationId);
}
}
@@ -385,6 +392,13 @@ export interface IUserDataSynchroniser {
//#endregion
// #region keys synced only in web
export const SYNC_SERVICE_URL_TYPE = 'sync.store.url.type';
export function getEnablementKey(resource: SyncResource) { return `sync.enable.${resource}`; }
// #endregion
// #region User Data Sync Services
export const IUserDataSyncResourceEnablementService = createDecorator<IUserDataSyncResourceEnablementService>('IUserDataSyncResourceEnablementService');
@@ -394,6 +408,8 @@ export interface IUserDataSyncResourceEnablementService {
readonly onDidChangeResourceEnablement: Event<[SyncResource, boolean]>;
isResourceEnabled(resource: SyncResource): boolean;
setResourceEnablement(resource: SyncResource, enabled: boolean): void;
getResourceSyncStateVersion(resource: SyncResource): string | undefined;
}
export interface ISyncTask {

137
src/vs/platform/userDataSync/common/userDataSyncIpc.ts
View File

@@ -3,115 +3,15 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IServerChannel, IChannel, IPCServer } from 'vs/base/parts/ipc/common/ipc';
import { IServerChannel, IChannel } from 'vs/base/parts/ipc/common/ipc';
import { Event } from 'vs/base/common/event';
import { IUserDataSyncService, IUserDataSyncUtilService, IUserDataAutoSyncService, IManualSyncTask, IUserDataManifest, IUserDataSyncStoreManagementService, SyncStatus } from 'vs/platform/userDataSync/common/userDataSync';
import { IUserDataSyncUtilService, IUserDataAutoSyncService, IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
import { URI } from 'vs/base/common/uri';
import { IStringDictionary } from 'vs/base/common/collections';
import { FormattingOptions } from 'vs/base/common/jsonFormatter';
import { ILogService } from 'vs/platform/log/common/log';
import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
export class UserDataSyncChannel implements IServerChannel {
constructor(private server: IPCServer, private readonly service: IUserDataSyncService, private readonly logService: ILogService) { }
listen(_: unknown, event: string): Event<any> {
switch (event) {
case 'onDidChangeStatus': return this.service.onDidChangeStatus;
case 'onDidChangeConflicts': return this.service.onDidChangeConflicts;
case 'onDidChangeLocal': return this.service.onDidChangeLocal;
case 'onDidChangeLastSyncTime': return this.service.onDidChangeLastSyncTime;
case 'onSyncErrors': return this.service.onSyncErrors;
case 'onDidResetLocal': return this.service.onDidResetLocal;
case 'onDidResetRemote': return this.service.onDidResetRemote;
}
throw new Error(`Event not found: ${event}`);
}
async call(context: any, command: string, args?: any): Promise<any> {
try {
const result = await this._call(context, command, args);
return result;
} catch (e) {
this.logService.error(e);
throw e;
}
}
private _call(context: any, command: string, args?: any): Promise<any> {
switch (command) {
case '_getInitialData': return Promise.resolve([this.service.status, this.service.conflicts, this.service.lastSyncTime]);
case 'createManualSyncTask': return this.createManualSyncTask();
case 'replace': return this.service.replace(URI.revive(args[0]));
case 'reset': return this.service.reset();
case 'resetRemote': return this.service.resetRemote();
case 'resetLocal': return this.service.resetLocal();
case 'hasPreviouslySynced': return this.service.hasPreviouslySynced();
case 'hasLocalData': return this.service.hasLocalData();
case 'accept': return this.service.accept(args[0], URI.revive(args[1]), args[2], args[3]);
case 'resolveContent': return this.service.resolveContent(URI.revive(args[0]));
case 'getLocalSyncResourceHandles': return this.service.getLocalSyncResourceHandles(args[0]);
case 'getRemoteSyncResourceHandles': return this.service.getRemoteSyncResourceHandles(args[0]);
case 'getAssociatedResources': return this.service.getAssociatedResources(args[0], { created: args[1].created, uri: URI.revive(args[1].uri) });
case 'getMachineId': return this.service.getMachineId(args[0], { created: args[1].created, uri: URI.revive(args[1].uri) });
}
throw new Error('Invalid call');
}
private async createManualSyncTask(): Promise<{ id: string, manifest: IUserDataManifest | null, status: SyncStatus }> {
const manualSyncTask = await this.service.createManualSyncTask();
const manualSyncTaskChannel = new ManualSyncTaskChannel(manualSyncTask, this.logService);
this.server.registerChannel(`manualSyncTask-${manualSyncTask.id}`, manualSyncTaskChannel);
return { id: manualSyncTask.id, manifest: manualSyncTask.manifest, status: manualSyncTask.status };
}
}
class ManualSyncTaskChannel implements IServerChannel {
constructor(
private readonly manualSyncTask: IManualSyncTask,
private readonly logService: ILogService
) { }
listen(_: unknown, event: string): Event<any> {
switch (event) {
case 'onSynchronizeResources': return this.manualSyncTask.onSynchronizeResources;
}
throw new Error(`Event not found: ${event}`);
}
async call(context: any, command: string, args?: any): Promise<any> {
try {
const result = await this._call(context, command, args);
return result;
} catch (e) {
this.logService.error(e);
throw e;
}
}
private async _call(context: any, command: string, args?: any): Promise<any> {
switch (command) {
case 'preview': return this.manualSyncTask.preview();
case 'accept': return this.manualSyncTask.accept(URI.revive(args[0]), args[1]);
case 'merge': return this.manualSyncTask.merge(URI.revive(args[0]));
case 'discard': return this.manualSyncTask.discard(URI.revive(args[0]));
case 'discardConflicts': return this.manualSyncTask.discardConflicts();
case 'apply': return this.manualSyncTask.apply();
case 'pull': return this.manualSyncTask.pull();
case 'push': return this.manualSyncTask.push();
case 'stop': return this.manualSyncTask.stop();
case '_getStatus': return this.manualSyncTask.status;
case 'dispose': return this.manualSyncTask.dispose();
}
throw new Error('Invalid call');
}
}
import { Disposable } from 'vs/base/common/lifecycle';
export class UserDataAutoSyncChannel implements IServerChannel {
@@ -235,3 +135,34 @@ export class UserDataSyncStoreManagementServiceChannel implements IServerChannel
throw new Error('Invalid call');
}
}
export class UserDataSyncStoreManagementServiceChannelClient extends Disposable {
readonly onDidChangeUserDataSyncStore: Event<void>;
constructor(private readonly channel: IChannel) {
super();
this.onDidChangeUserDataSyncStore = this.channel.listen<void>('onDidChangeUserDataSyncStore');
}
async switch(type: UserDataSyncStoreType): Promise<void> {
return this.channel.call('switch', [type]);
}
async getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore> {
const userDataSyncStore = await this.channel.call<IUserDataSyncStore>('getPreviousUserDataSyncStore');
return this.revive(userDataSyncStore);
}
private revive(userDataSyncStore: IUserDataSyncStore): IUserDataSyncStore {
return {
url: URI.revive(userDataSyncStore.url),
type: userDataSyncStore.type,
defaultUrl: URI.revive(userDataSyncStore.defaultUrl),
insidersUrl: URI.revive(userDataSyncStore.insidersUrl),
stableUrl: URI.revive(userDataSyncStore.stableUrl),
canSwitch: userDataSyncStore.canSwitch,
authenticationProviders: userDataSyncStore.authenticationProviders,
};
}
}

6
src/vs/platform/userDataSync/common/userDataSyncLog.ts
View File

@@ -4,10 +4,10 @@
*--------------------------------------------------------------------------------------------*/
import { IUserDataSyncLogService } from 'vs/platform/userDataSync/common/userDataSync';
import { AbstractLogService, ILoggerService, ILogger } from 'vs/platform/log/common/log';
import { AbstractLogger, ILoggerService, ILogger } from 'vs/platform/log/common/log';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
export class UserDataSyncLogService extends AbstractLogService implements IUserDataSyncLogService {
export class UserDataSyncLogService extends AbstractLogger implements IUserDataSyncLogService {
declare readonly _serviceBrand: undefined;
private readonly logger: ILogger;
@@ -17,7 +17,7 @@ export class UserDataSyncLogService extends AbstractLogService implements IUserD
@IEnvironmentService environmentService: IEnvironmentService
) {
super();
this.logger = this._register(loggerService.getLogger(environmentService.userDataSyncLogResource));
this.logger = this._register(loggerService.createLogger(environmentService.userDataSyncLogResource, { name: 'settingssync' }));
}
trace(message: string, ...args: any[]): void {

16
src/vs/platform/userDataSync/common/userDataSyncResourceEnablementService.ts
View File

@@ -3,19 +3,17 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IUserDataSyncResourceEnablementService, ALL_SYNC_RESOURCES, SyncResource } from 'vs/platform/userDataSync/common/userDataSync';
import { IUserDataSyncResourceEnablementService, ALL_SYNC_RESOURCES, SyncResource, getEnablementKey } from 'vs/platform/userDataSync/common/userDataSync';
import { Disposable } from 'vs/base/common/lifecycle';
import { Emitter, Event } from 'vs/base/common/event';
import { IStorageService, IStorageValueChangeEvent, StorageScope, StorageTarget } from 'vs/platform/storage/common/storage';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { isWeb } from 'vs/base/common/platform';
type SyncEnablementClassification = {
enabled?: { classification: 'SystemMetaData', purpose: 'FeatureInsight', isMeasurement: true };
};
const enablementKey = 'sync.enable';
function getEnablementKey(resource: SyncResource) { return `${enablementKey}.${resource}`; }
export class UserDataSyncResourceEnablementService extends Disposable implements IUserDataSyncResourceEnablementService {
_serviceBrand: any;
@@ -39,10 +37,18 @@ export class UserDataSyncResourceEnablementService extends Disposable implements
if (this.isResourceEnabled(resource) !== enabled) {
const resourceEnablementKey = getEnablementKey(resource);
this.telemetryService.publicLog2<{ enabled: boolean }, SyncEnablementClassification>(resourceEnablementKey, { enabled });
this.storageService.store(resourceEnablementKey, enabled, StorageScope.GLOBAL, StorageTarget.MACHINE);
this.storeResourceEnablement(resourceEnablementKey, enabled);
}
}
getResourceSyncStateVersion(resource: SyncResource): string | undefined {
return undefined;
}
private storeResourceEnablement(resourceEnablementKey: string, enabled: boolean): void {
this.storageService.store(resourceEnablementKey, enabled, StorageScope.GLOBAL, isWeb ? StorageTarget.USER /* sync in web */ : StorageTarget.MACHINE);
}
private onDidStorageChange(storageChangeEvent: IStorageValueChangeEvent): void {
if (storageChangeEvent.scope === StorageScope.GLOBAL) {
const resourceKey = ALL_SYNC_RESOURCES.filter(resourceKey => getEnablementKey(resourceKey) === storageChangeEvent.key)[0];

55
src/vs/platform/userDataSync/common/userDataSyncService.ts
View File

@@ -5,7 +5,7 @@
import {
IUserDataSyncService, SyncStatus, IUserDataSyncStoreService, SyncResource, IUserDataSyncLogService, IUserDataSynchroniser, UserDataSyncErrorCode,
UserDataSyncError, ISyncResourceHandle, IUserDataManifest, ISyncTask, IResourcePreview, IManualSyncTask, ISyncResourcePreview, HEADER_EXECUTION_ID, MergeState, Change, IUserDataSyncStoreManagementService, UserDataSyncStoreError
UserDataSyncError, ISyncResourceHandle, IUserDataManifest, ISyncTask, IResourcePreview, IManualSyncTask, ISyncResourcePreview, MergeState, Change, IUserDataSyncStoreManagementService, UserDataSyncStoreError, createSyncHeaders
} from 'vs/platform/userDataSync/common/userDataSync';
import { Disposable } from 'vs/base/common/lifecycle';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
@@ -37,12 +37,6 @@ type SyncErrorClassification = {
const LAST_SYNC_TIME_KEY = 'sync.lastSyncTime';
function createSyncHeaders(executionId: string): IHeaders {
const headers: IHeaders = {};
headers[HEADER_EXECUTION_ID] = executionId;
return headers;
}
export class UserDataSyncService extends Disposable implements IUserDataSyncService {
_serviceBrand: any;
@@ -195,8 +189,29 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
try {
await synchroniser.sync(manifest, syncHeaders);
} catch (e) {
this.handleSynchronizerError(e, synchroniser.resource);
this._syncErrors.push([synchroniser.resource, UserDataSyncError.toUserDataSyncError(e)]);
if (e instanceof UserDataSyncError) {
// Bail out for following errors
switch (e.code) {
case UserDataSyncErrorCode.TooLarge:
throw new UserDataSyncError(e.message, e.code, synchroniser.resource);
case UserDataSyncErrorCode.TooManyRequests:
case UserDataSyncErrorCode.TooManyRequestsAndRetryAfter:
case UserDataSyncErrorCode.LocalTooManyRequests:
case UserDataSyncErrorCode.Gone:
case UserDataSyncErrorCode.UpgradeRequired:
case UserDataSyncErrorCode.IncompatibleRemoteContent:
case UserDataSyncErrorCode.IncompatibleLocalContent:
throw e;
}
}
// Log and report other errors and continue
const userDataSyncError = UserDataSyncError.toUserDataSyncError(e);
this.reportUserDataSyncError(userDataSyncError, executionId);
this.logService.error(e);
this.logService.error(`${synchroniser.resource}: ${toErrorMessage(e)}`);
this._syncErrors.push([synchroniser.resource, userDataSyncError]);
}
}
@@ -371,26 +386,6 @@ export class UserDataSyncService extends Disposable implements IUserDataSyncServ
}
}
private handleSynchronizerError(e: Error, source: SyncResource): void {
if (e instanceof UserDataSyncError) {
switch (e.code) {
case UserDataSyncErrorCode.TooLarge:
throw new UserDataSyncError(e.message, e.code, source);
case UserDataSyncErrorCode.TooManyRequests:
case UserDataSyncErrorCode.TooManyRequestsAndRetryAfter:
case UserDataSyncErrorCode.LocalTooManyRequests:
case UserDataSyncErrorCode.Gone:
case UserDataSyncErrorCode.UpgradeRequired:
case UserDataSyncErrorCode.IncompatibleRemoteContent:
case UserDataSyncErrorCode.IncompatibleLocalContent:
throw e;
}
}
this.logService.error(e);
this.logService.error(`${source}: ${toErrorMessage(e)}`);
}
private reportUserDataSyncError(userDataSyncError: UserDataSyncError, executionId: string) {
this.telemetryService.publicLog2<{ code: string, service: string, url?: string, resource?: string, executionId?: string }, SyncErrorClassification>('sync/error',
{ code: userDataSyncError.code, url: userDataSyncError instanceof UserDataSyncStoreError ? userDataSyncError.url : undefined, resource: userDataSyncError.resource, executionId, service: this.userDataSyncStoreManagementService.userDataSyncStore!.url.toString() });
@@ -732,7 +727,7 @@ class ManualSyncTask extends Disposable implements IManualSyncTask {
this.synchronizingResources = [];
}
dispose(): void {
override dispose(): void {
this.reset();
this.isDisposed = true;
}

381
src/vs/platform/userDataSync/common/userDataSyncServiceIpc.ts Normal file
View File

@@ -0,0 +1,381 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IServerChannel, IChannel } from 'vs/base/parts/ipc/common/ipc';
import { Emitter, Event } from 'vs/base/common/event';
import { IUserDataSyncService, IManualSyncTask, IUserDataManifest, SyncStatus, IResourcePreview, ISyncResourceHandle, ISyncResourcePreview, ISyncTask, SyncResource, UserDataSyncError } from 'vs/platform/userDataSync/common/userDataSync';
import { URI } from 'vs/base/common/uri';
import { ILogService } from 'vs/platform/log/common/log';
import { Disposable, DisposableStore } from 'vs/base/common/lifecycle';
import { CancellationToken } from 'vs/base/common/cancellation';
import { isArray } from 'vs/base/common/types';
type ManualSyncTaskEvent<T> = { manualSyncTaskId: string, data: T };
export class UserDataSyncChannel implements IServerChannel {
private readonly manualSyncTasks = new Map<string, { manualSyncTask: IManualSyncTask, disposables: DisposableStore }>();
private readonly onManualSynchronizeResources = new Emitter<ManualSyncTaskEvent<[SyncResource, URI[]][]>>();
constructor(private readonly service: IUserDataSyncService, private readonly logService: ILogService) { }
listen(_: unknown, event: string): Event<any> {
switch (event) {
// sync
case 'onDidChangeStatus': return this.service.onDidChangeStatus;
case 'onDidChangeConflicts': return this.service.onDidChangeConflicts;
case 'onDidChangeLocal': return this.service.onDidChangeLocal;
case 'onDidChangeLastSyncTime': return this.service.onDidChangeLastSyncTime;
case 'onSyncErrors': return this.service.onSyncErrors;
case 'onDidResetLocal': return this.service.onDidResetLocal;
case 'onDidResetRemote': return this.service.onDidResetRemote;
// manual sync
case 'manualSync/onSynchronizeResources': return this.onManualSynchronizeResources.event;
}
throw new Error(`Event not found: ${event}`);
}
async call(context: any, command: string, args?: any): Promise<any> {
try {
const result = await this._call(context, command, args);
return result;
} catch (e) {
this.logService.error(e);
throw e;
}
}
private async _call(context: any, command: string, args?: any): Promise<any> {
switch (command) {
// sync
case '_getInitialData': return Promise.resolve([this.service.status, this.service.conflicts, this.service.lastSyncTime]);
case 'replace': return this.service.replace(URI.revive(args[0]));
case 'reset': return this.service.reset();
case 'resetRemote': return this.service.resetRemote();
case 'resetLocal': return this.service.resetLocal();
case 'hasPreviouslySynced': return this.service.hasPreviouslySynced();
case 'hasLocalData': return this.service.hasLocalData();
case 'accept': return this.service.accept(args[0], URI.revive(args[1]), args[2], args[3]);
case 'resolveContent': return this.service.resolveContent(URI.revive(args[0]));
case 'getLocalSyncResourceHandles': return this.service.getLocalSyncResourceHandles(args[0]);
case 'getRemoteSyncResourceHandles': return this.service.getRemoteSyncResourceHandles(args[0]);
case 'getAssociatedResources': return this.service.getAssociatedResources(args[0], { created: args[1].created, uri: URI.revive(args[1].uri) });
case 'getMachineId': return this.service.getMachineId(args[0], { created: args[1].created, uri: URI.revive(args[1].uri) });
case 'createManualSyncTask': return this.createManualSyncTask();
}
// manual sync
if (command.startsWith('manualSync/')) {
const manualSyncTaskCommand = command.substring('manualSync/'.length);
const manualSyncTaskId = args[0];
const manualSyncTask = this.getManualSyncTask(manualSyncTaskId);
args = (<Array<any>>args).slice(1);
switch (manualSyncTaskCommand) {
case 'preview': return manualSyncTask.preview();
case 'accept': return manualSyncTask.accept(URI.revive(args[0]), args[1]);
case 'merge': return manualSyncTask.merge(URI.revive(args[0]));
case 'discard': return manualSyncTask.discard(URI.revive(args[0]));
case 'discardConflicts': return manualSyncTask.discardConflicts();
case 'apply': return manualSyncTask.apply();
case 'pull': return manualSyncTask.pull();
case 'push': return manualSyncTask.push();
case 'stop': return manualSyncTask.stop();
case '_getStatus': return manualSyncTask.status;
case 'dispose': return this.disposeManualSyncTask(manualSyncTask);
}
}
throw new Error('Invalid call');
}
private getManualSyncTask(manualSyncTaskId: string): IManualSyncTask {
const value = this.manualSyncTasks.get(this.createKey(manualSyncTaskId));
if (!value) {
throw new Error(`Manual sync taks not found: ${manualSyncTaskId}`);
}
return value.manualSyncTask;
}
private async createManualSyncTask(): Promise<{ id: string, manifest: IUserDataManifest | null, status: SyncStatus }> {
const disposables = new DisposableStore();
const manualSyncTask = disposables.add(await this.service.createManualSyncTask());
disposables.add(manualSyncTask.onSynchronizeResources(synchronizeResources => this.onManualSynchronizeResources.fire({ manualSyncTaskId: manualSyncTask.id, data: synchronizeResources })));
this.manualSyncTasks.set(this.createKey(manualSyncTask.id), { manualSyncTask, disposables });
return { id: manualSyncTask.id, manifest: manualSyncTask.manifest, status: manualSyncTask.status };
}
private disposeManualSyncTask(manualSyncTask: IManualSyncTask): void {
manualSyncTask.dispose();
const key = this.createKey(manualSyncTask.id);
this.manualSyncTasks.get(key)?.disposables.dispose();
this.manualSyncTasks.delete(key);
}
private createKey(manualSyncTaskId: string): string { return `manualSyncTask-${manualSyncTaskId}`; }
}
export class UserDataSyncChannelClient extends Disposable implements IUserDataSyncService {
declare readonly _serviceBrand: undefined;
private readonly channel: IChannel;
private _status: SyncStatus = SyncStatus.Uninitialized;
get status(): SyncStatus { return this._status; }
private _onDidChangeStatus: Emitter<SyncStatus> = this._register(new Emitter<SyncStatus>());
readonly onDidChangeStatus: Event<SyncStatus> = this._onDidChangeStatus.event;
get onDidChangeLocal(): Event<SyncResource> { return this.channel.listen<SyncResource>('onDidChangeLocal'); }
private _conflicts: [SyncResource, IResourcePreview[]][] = [];
get conflicts(): [SyncResource, IResourcePreview[]][] { return this._conflicts; }
private _onDidChangeConflicts: Emitter<[SyncResource, IResourcePreview[]][]> = this._register(new Emitter<[SyncResource, IResourcePreview[]][]>());
readonly onDidChangeConflicts: Event<[SyncResource, IResourcePreview[]][]> = this._onDidChangeConflicts.event;
private _lastSyncTime: number | undefined = undefined;
get lastSyncTime(): number | undefined { return this._lastSyncTime; }
private _onDidChangeLastSyncTime: Emitter<number> = this._register(new Emitter<number>());
readonly onDidChangeLastSyncTime: Event<number> = this._onDidChangeLastSyncTime.event;
private _onSyncErrors: Emitter<[SyncResource, UserDataSyncError][]> = this._register(new Emitter<[SyncResource, UserDataSyncError][]>());
readonly onSyncErrors: Event<[SyncResource, UserDataSyncError][]> = this._onSyncErrors.event;
get onDidResetLocal(): Event<void> { return this.channel.listen<void>('onDidResetLocal'); }
get onDidResetRemote(): Event<void> { return this.channel.listen<void>('onDidResetRemote'); }
constructor(userDataSyncChannel: IChannel) {
super();
this.channel = {
call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T> {
return userDataSyncChannel.call(command, arg, cancellationToken)
.then(null, error => { throw UserDataSyncError.toUserDataSyncError(error); });
},
listen<T>(event: string, arg?: any): Event<T> {
return userDataSyncChannel.listen(event, arg);
}
};
this.channel.call<[SyncStatus, [SyncResource, IResourcePreview[]][], number | undefined]>('_getInitialData').then(([status, conflicts, lastSyncTime]) => {
this.updateStatus(status);
this.updateConflicts(conflicts);
if (lastSyncTime) {
this.updateLastSyncTime(lastSyncTime);
}
this._register(this.channel.listen<SyncStatus>('onDidChangeStatus')(status => this.updateStatus(status)));
this._register(this.channel.listen<number>('onDidChangeLastSyncTime')(lastSyncTime => this.updateLastSyncTime(lastSyncTime)));
});
this._register(this.channel.listen<[SyncResource, IResourcePreview[]][]>('onDidChangeConflicts')(conflicts => this.updateConflicts(conflicts)));
this._register(this.channel.listen<[SyncResource, Error][]>('onSyncErrors')(errors => this._onSyncErrors.fire(errors.map(([source, error]) => ([source, UserDataSyncError.toUserDataSyncError(error)])))));
}
createSyncTask(): Promise<ISyncTask> {
throw new Error('not supported');
}
async createManualSyncTask(): Promise<IManualSyncTask> {
const { id, manifest, status } = await this.channel.call<{ id: string, manifest: IUserDataManifest | null, status: SyncStatus }>('createManualSyncTask');
const that = this;
const manualSyncTaskChannelClient = new ManualSyncTaskChannelClient(id, manifest, status, {
async call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T> {
return that.channel.call<T>(`manualSync/${command}`, [id, ...(isArray(arg) ? arg : [arg])], cancellationToken);
},
listen<T>(event: string, arg?: any): Event<T> {
return Event.map(
Event.filter(that.channel.listen<{ manualSyncTaskId: string, data: T }>(`manualSync/${event}`, arg), e => !manualSyncTaskChannelClient.isDiposed() && e.manualSyncTaskId === id),
e => e.data);
}
});
return manualSyncTaskChannelClient;
}
replace(uri: URI): Promise<void> {
return this.channel.call('replace', [uri]);
}
reset(): Promise<void> {
return this.channel.call('reset');
}
resetRemote(): Promise<void> {
return this.channel.call('resetRemote');
}
resetLocal(): Promise<void> {
return this.channel.call('resetLocal');
}
hasPreviouslySynced(): Promise<boolean> {
return this.channel.call('hasPreviouslySynced');
}
hasLocalData(): Promise<boolean> {
return this.channel.call('hasLocalData');
}
accept(syncResource: SyncResource, resource: URI, content: string | null, apply: boolean): Promise<void> {
return this.channel.call('accept', [syncResource, resource, content, apply]);
}
resolveContent(resource: URI): Promise<string | null> {
return this.channel.call('resolveContent', [resource]);
}
async getLocalSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> {
const handles = await this.channel.call<ISyncResourceHandle[]>('getLocalSyncResourceHandles', [resource]);
return handles.map(({ created, uri }) => ({ created, uri: URI.revive(uri) }));
}
async getRemoteSyncResourceHandles(resource: SyncResource): Promise<ISyncResourceHandle[]> {
const handles = await this.channel.call<ISyncResourceHandle[]>('getRemoteSyncResourceHandles', [resource]);
return handles.map(({ created, uri }) => ({ created, uri: URI.revive(uri) }));
}
async getAssociatedResources(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<{ resource: URI, comparableResource: URI }[]> {
const result = await this.channel.call<{ resource: URI, comparableResource: URI }[]>('getAssociatedResources', [resource, syncResourceHandle]);
return result.map(({ resource, comparableResource }) => ({ resource: URI.revive(resource), comparableResource: URI.revive(comparableResource) }));
}
async getMachineId(resource: SyncResource, syncResourceHandle: ISyncResourceHandle): Promise<string | undefined> {
return this.channel.call<string | undefined>('getMachineId', [resource, syncResourceHandle]);
}
private async updateStatus(status: SyncStatus): Promise<void> {
this._status = status;
this._onDidChangeStatus.fire(status);
}
private async updateConflicts(conflicts: [SyncResource, IResourcePreview[]][]): Promise<void> {
// Revive URIs
this._conflicts = conflicts.map(([syncResource, conflicts]) =>
([
syncResource,
conflicts.map(r =>
({
...r,
localResource: URI.revive(r.localResource),
remoteResource: URI.revive(r.remoteResource),
previewResource: URI.revive(r.previewResource),
}))
]));
this._onDidChangeConflicts.fire(this._conflicts);
}
private updateLastSyncTime(lastSyncTime: number): void {
if (this._lastSyncTime !== lastSyncTime) {
this._lastSyncTime = lastSyncTime;
this._onDidChangeLastSyncTime.fire(lastSyncTime);
}
}
}
class ManualSyncTaskChannelClient extends Disposable implements IManualSyncTask {
private readonly channel: IChannel;
get onSynchronizeResources(): Event<[SyncResource, URI[]][]> { return this.channel.listen<[SyncResource, URI[]][]>('onSynchronizeResources'); }
private _status: SyncStatus;
get status(): SyncStatus { return this._status; }
constructor(
readonly id: string,
readonly manifest: IUserDataManifest | null,
status: SyncStatus,
manualSyncTaskChannel: IChannel
) {
super();
this._status = status;
const that = this;
this.channel = {
async call<T>(command: string, arg?: any, cancellationToken?: CancellationToken): Promise<T> {
try {
const result = await manualSyncTaskChannel.call<T>(command, arg, cancellationToken);
if (!that.isDiposed()) {
that._status = await manualSyncTaskChannel.call<SyncStatus>('_getStatus');
}
return result;
} catch (error) {
throw UserDataSyncError.toUserDataSyncError(error);
}
},
listen<T>(event: string, arg?: any): Event<T> {
return manualSyncTaskChannel.listen(event, arg);
}
};
}
async preview(): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('preview');
return this.deserializePreviews(previews);
}
async accept(resource: URI, content?: string | null): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('accept', [resource, content]);
return this.deserializePreviews(previews);
}
async merge(resource?: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('merge', [resource]);
return this.deserializePreviews(previews);
}
async discard(resource: URI): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('discard', [resource]);
return this.deserializePreviews(previews);
}
async discardConflicts(): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('discardConflicts');
return this.deserializePreviews(previews);
}
async apply(): Promise<[SyncResource, ISyncResourcePreview][]> {
const previews = await this.channel.call<[SyncResource, ISyncResourcePreview][]>('apply');
return this.deserializePreviews(previews);
}
pull(): Promise<void> {
return this.channel.call('pull');
}
push(): Promise<void> {
return this.channel.call('push');
}
stop(): Promise<void> {
return this.channel.call('stop');
}
private _disposed = false;
isDiposed() { return this._disposed; }
override dispose(): void {
this._disposed = true;
this.channel.call('dispose');
}
private deserializePreviews(previews: [SyncResource, ISyncResourcePreview][]): [SyncResource, ISyncResourcePreview][] {
return previews.map(([syncResource, preview]) =>
([
syncResource,
{
isLastSyncFromCurrentMachine: preview.isLastSyncFromCurrentMachine,
resourcePreviews: preview.resourcePreviews.map(r => ({
...r,
localResource: URI.revive(r.localResource),
remoteResource: URI.revive(r.remoteResource),
previewResource: URI.revive(r.previewResource),
acceptedResource: URI.revive(r.acceptedResource),
}))
}
]));
}
}

35
src/vs/platform/userDataSync/common/userDataSyncStoreService.ts
View File

@@ -4,13 +4,14 @@
*--------------------------------------------------------------------------------------------*/
import { Disposable, toDisposable, } from 'vs/base/common/lifecycle';
import { IUserData, IUserDataSyncStoreService, UserDataSyncErrorCode, IUserDataSyncStore, ServerResource, UserDataSyncStoreError, IUserDataSyncLogService, IUserDataManifest, IResourceRefHandle, HEADER_OPERATION_ID, HEADER_EXECUTION_ID, CONFIGURATION_SYNC_STORE_KEY, IAuthenticationProvider, IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStoreClient } from 'vs/platform/userDataSync/common/userDataSync';
import { IUserData, IUserDataSyncStoreService, UserDataSyncErrorCode, IUserDataSyncStore, ServerResource, UserDataSyncStoreError, IUserDataSyncLogService, IUserDataManifest, IResourceRefHandle, HEADER_OPERATION_ID, HEADER_EXECUTION_ID, CONFIGURATION_SYNC_STORE_KEY, IAuthenticationProvider, IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStoreClient, SYNC_SERVICE_URL_TYPE } from 'vs/platform/userDataSync/common/userDataSync';
import { IRequestService, asText, isSuccess as isSuccessContext, asJson } from 'vs/platform/request/common/request';
import { joinPath, relativePath } from 'vs/base/common/resources';
import { CancellationToken } from 'vs/base/common/cancellation';
import { IHeaders, IRequestOptions, IRequestContext } from 'vs/base/parts/request/common/request';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { IProductService, ConfigurationSyncStore } from 'vs/platform/product/common/productService';
import { IProductService } from 'vs/platform/product/common/productService';
import { ConfigurationSyncStore } from 'vs/base/common/product';
import { getServiceMachineId } from 'vs/platform/serviceMachineId/common/serviceMachineId';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { IFileService } from 'vs/platform/files/common/files';
@@ -23,7 +24,6 @@ import { isString, isObject, isArray } from 'vs/base/common/types';
import { URI } from 'vs/base/common/uri';
import { getErrorMessage, isPromiseCanceledError } from 'vs/base/common/errors';
const SYNC_SERVICE_URL_TYPE = 'sync.store.url.type';
const SYNC_PREVIOUS_STORE = 'sync.previous.store';
const DONOT_MAKE_REQUESTS_UNTIL_KEY = 'sync.donot-make-requests-until';
const USER_SESSION_ID_KEY = 'sync.user-session-id';
@@ -31,7 +31,7 @@ const MACHINE_SESSION_ID_KEY = 'sync.machine-session-id';
const REQUEST_SESSION_LIMIT = 100;
const REQUEST_SESSION_INTERVAL = 1000 * 60 * 5; /* 5 minutes */
type UserDataSyncStore = IUserDataSyncStore & { defaultType?: UserDataSyncStoreType; type?: UserDataSyncStoreType };
type UserDataSyncStore = IUserDataSyncStore & { defaultType: UserDataSyncStoreType; };
export abstract class AbstractUserDataSyncStoreManagementService extends Disposable implements IUserDataSyncStoreManagementService {
@@ -42,6 +42,13 @@ export abstract class AbstractUserDataSyncStoreManagementService extends Disposa
private _userDataSyncStore: UserDataSyncStore | undefined;
get userDataSyncStore(): UserDataSyncStore | undefined { return this._userDataSyncStore; }
protected get userDataSyncStoreType(): UserDataSyncStoreType | undefined {
return this.storageService.get(SYNC_SERVICE_URL_TYPE, StorageScope.GLOBAL) as UserDataSyncStoreType;
}
protected set userDataSyncStoreType(type: UserDataSyncStoreType | undefined) {
this.storageService.store(SYNC_SERVICE_URL_TYPE, type, StorageScope.GLOBAL, isWeb ? StorageTarget.USER /* sync in web */ : StorageTarget.MACHINE);
}
constructor(
@IProductService protected readonly productService: IProductService,
@IConfigurationService protected readonly configurationService: IConfigurationService,
@@ -49,6 +56,7 @@ export abstract class AbstractUserDataSyncStoreManagementService extends Disposa
) {
super();
this.updateUserDataSyncStore();
this._register(Event.filter(storageService.onDidChangeValue, e => e.key === SYNC_SERVICE_URL_TYPE && e.scope === StorageScope.GLOBAL && this.userDataSyncStoreType !== this.userDataSyncStore?.type)(() => this.updateUserDataSyncStore()));
}
protected updateUserDataSyncStore(): void {
@@ -56,8 +64,8 @@ export abstract class AbstractUserDataSyncStoreManagementService extends Disposa
this._onDidChangeUserDataSyncStore.fire();
}
protected toUserDataSyncStore(productStore: ConfigurationSyncStore | undefined, configuredStore?: ConfigurationSyncStore): UserDataSyncStore | undefined {
// Web overrides
protected toUserDataSyncStore(productStore: ConfigurationSyncStore & { web?: ConfigurationSyncStore } | undefined, configuredStore?: ConfigurationSyncStore): UserDataSyncStore | undefined {
// Check for web overrides for backward compatibility while reading previous store
productStore = isWeb && productStore?.web ? { ...productStore, ...productStore.web } : productStore;
const value: Partial<ConfigurationSyncStore> = { ...(productStore || {}), ...(configuredStore || {}) };
if (value
@@ -67,7 +75,8 @@ export abstract class AbstractUserDataSyncStoreManagementService extends Disposa
) {
const syncStore = value as ConfigurationSyncStore;
const canSwitch = !!syncStore.canSwitch && !configuredStore?.url;
const type: UserDataSyncStoreType | undefined = canSwitch ? this.storageService.get(SYNC_SERVICE_URL_TYPE, StorageScope.GLOBAL) as UserDataSyncStoreType : undefined;
const defaultType: UserDataSyncStoreType = syncStore.url === syncStore.insidersUrl ? 'insiders' : 'stable';
const type: UserDataSyncStoreType = (canSwitch ? this.userDataSyncStoreType : undefined) || defaultType;
const url = configuredStore?.url ||
(type === 'insiders' ? syncStore.insidersUrl
: type === 'stable' ? syncStore.stableUrl
@@ -75,11 +84,11 @@ export abstract class AbstractUserDataSyncStoreManagementService extends Disposa
return {
url: URI.parse(url),
type,
defaultType: syncStore.url === syncStore.insidersUrl ? 'insiders' : syncStore.url === syncStore.stableUrl ? 'stable' : undefined,
defaultType,
defaultUrl: URI.parse(syncStore.url),
stableUrl: URI.parse(syncStore.stableUrl),
insidersUrl: URI.parse(syncStore.insidersUrl),
canSwitch: !!syncStore.canSwitch && !configuredStore?.url,
canSwitch,
authenticationProviders: Object.keys(syncStore.authenticationProviders).reduce<IAuthenticationProvider[]>((result, id) => {
result.push({ id, scopes: syncStore!.authenticationProviders[id].scopes });
return result;
@@ -119,12 +128,8 @@ export class UserDataSyncStoreManagementService extends AbstractUserDataSyncStor
}
async switch(type: UserDataSyncStoreType): Promise<void> {
if (this.userDataSyncStore?.canSwitch && type !== this.userDataSyncStore.type) {
if (type === this.userDataSyncStore.defaultType) {
this.storageService.remove(SYNC_SERVICE_URL_TYPE, StorageScope.GLOBAL);
} else {
this.storageService.store(SYNC_SERVICE_URL_TYPE, type, StorageScope.GLOBAL, StorageTarget.MACHINE);
}
if (type !== this.userDataSyncStoreType) {
this.userDataSyncStoreType = type;
this.updateUserDataSyncStore();
}
}

4
src/vs/platform/userDataSync/electron-sandbox/userDataAutoSyncService.ts
View File

@@ -11,10 +11,12 @@ import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/use
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
import { IProductService } from 'vs/platform/product/common/productService';
export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
constructor(
@IProductService productService: IProductService,
@IUserDataSyncStoreManagementService userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
@IUserDataSyncResourceEnablementService userDataSyncResourceEnablementService: IUserDataSyncResourceEnablementService,
@@ -27,7 +29,7 @@ export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
@IStorageService storageService: IStorageService,
@IUserDataAutoSyncEnablementService userDataAutoSyncEnablementService: IUserDataAutoSyncEnablementService,
) {
super(userDataSyncStoreManagementService, userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, storageService, userDataAutoSyncEnablementService);
super(productService, userDataSyncStoreManagementService, userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, storageService, userDataAutoSyncEnablementService);
this._register(Event.debounce<string, string[]>(Event.any<string>(
Event.map(nativeHostService.onDidFocusWindow, () => 'windowFocus'),

224
src/vs/platform/userDataSync/test/common/extensionsMerge.test.ts
View File

@@ -18,10 +18,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, null, null, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, localExtensions);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, localExtensions);
});
test('merge returns local extension if remote does not exist with ignored extensions', () => {
@@ -37,10 +37,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, null, null, [], ['a']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge returns local extension if remote does not exist with ignored extensions (ignore case)', () => {
@@ -56,10 +56,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, null, null, [], ['A']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge returns local extension if remote does not exist with skipped extensions', () => {
@@ -79,10 +79,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, null, null, skippedExtension, []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge returns local extension if remote does not exist with skipped and ignored extensions', () => {
@@ -101,10 +101,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, null, null, skippedExtension, ['a']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when there is no base', () => {
@@ -125,10 +125,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], []);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when there is no base and with ignored extensions', () => {
@@ -148,10 +148,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], ['a']);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when remote is moved forwarded', () => {
@@ -170,10 +170,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], []);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'a', uuid: 'a' }, { id: 'd', uuid: 'd' }]);
assert.deepEqual(actual.updated, []);
assert.equal(actual.remote, null);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'a', uuid: 'a' }, { id: 'd', uuid: 'd' }]);
assert.deepStrictEqual(actual.updated, []);
assert.strictEqual(actual.remote, null);
});
test('merge local and remote extensions when remote is moved forwarded with disabled extension', () => {
@@ -193,10 +193,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], []);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'a', uuid: 'a' }]);
assert.deepEqual(actual.updated, [{ identifier: { id: 'd', uuid: 'd' }, disabled: true, installed: true, version: '1.0.0' }]);
assert.equal(actual.remote, null);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'a', uuid: 'a' }]);
assert.deepStrictEqual(actual.updated, [{ identifier: { id: 'd', uuid: 'd' }, disabled: true, installed: true, version: '1.0.0' }]);
assert.strictEqual(actual.remote, null);
});
test('merge local and remote extensions when remote moved forwarded with ignored extensions', () => {
@@ -215,10 +215,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], ['a']);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepEqual(actual.updated, []);
assert.equal(actual.remote, null);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepStrictEqual(actual.updated, []);
assert.strictEqual(actual.remote, null);
});
test('merge local and remote extensions when remote is moved forwarded with skipped extensions', () => {
@@ -239,10 +239,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, []);
assert.deepEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepEqual(actual.updated, []);
assert.equal(actual.remote, null);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'b', uuid: 'b' }, installed: true, version: '1.0.0' }, { identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepStrictEqual(actual.updated, []);
assert.strictEqual(actual.remote, null);
});
test('merge local and remote extensions when remote is moved forwarded with skipped and ignored extensions', () => {
@@ -263,10 +263,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, ['b']);
assert.deepEqual(actual.added, [{ identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepEqual(actual.updated, []);
assert.equal(actual.remote, null);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'd', uuid: 'd' }]);
assert.deepStrictEqual(actual.updated, []);
assert.strictEqual(actual.remote, null);
});
test('merge local and remote extensions when local is moved forwarded', () => {
@@ -285,10 +285,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, localExtensions);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, localExtensions);
});
test('merge local and remote extensions when local is moved forwarded with disabled extensions', () => {
@@ -308,10 +308,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, localExtensions);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, localExtensions);
});
test('merge local and remote extensions when local is moved forwarded with ignored settings', () => {
@@ -330,10 +330,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], ['b']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, [
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, [
{ identifier: { id: 'c', uuid: 'c' }, installed: true, version: '1.0.0' },
]);
});
@@ -362,10 +362,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when local is moved forwarded with skipped and ignored extensions', () => {
@@ -391,10 +391,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, ['c']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when both moved forwarded', () => {
@@ -420,10 +420,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], []);
assert.deepEqual(actual.added, [{ identifier: { id: 'e', uuid: 'e' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, [{ id: 'a', uuid: 'a' }]);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'e', uuid: 'e' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, [{ id: 'a', uuid: 'a' }]);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when both moved forwarded with ignored extensions', () => {
@@ -449,10 +449,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, [], ['a', 'e']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when both moved forwarded with skipped extensions', () => {
@@ -480,10 +480,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, []);
assert.deepEqual(actual.added, [{ identifier: { id: 'e', uuid: 'e' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'e', uuid: 'e' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge local and remote extensions when both moved forwarded with skipped and ignoredextensions', () => {
@@ -511,10 +511,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, baseExtensions, skippedExtensions, ['e']);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge when remote extension has no uuid and different extension id case', () => {
@@ -536,10 +536,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], []);
assert.deepEqual(actual.added, [{ identifier: { id: 'd', uuid: 'd' }, installed: true, version: '1.0.0' }]);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, [{ identifier: { id: 'd', uuid: 'd' }, installed: true, version: '1.0.0' }]);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge when remote extension is not an installed extension', () => {
@@ -553,10 +553,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when remote extension is not an installed extension but is an installed extension locally', () => {
@@ -569,10 +569,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, localExtensions);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, localExtensions);
});
test('merge when an extension is not an installed extension remotely and does not exist locally', () => {
@@ -586,10 +586,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, remoteExtensions, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when an extension is an installed extension remotely but not locally and updated locally', () => {
@@ -605,10 +605,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, remoteExtensions, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
test('merge when an extension is an installed extension remotely but not locally and updated remotely', () => {
@@ -621,10 +621,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, localExtensions, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, remoteExtensions);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, remoteExtensions);
assert.deepStrictEqual(actual.remote, null);
});
test('merge not installed extensions', () => {
@@ -641,10 +641,10 @@ suite('ExtensionsMerge', () => {
const actual = merge(localExtensions, remoteExtensions, null, [], []);
assert.deepEqual(actual.added, []);
assert.deepEqual(actual.removed, []);
assert.deepEqual(actual.updated, []);
assert.deepEqual(actual.remote, expected);
assert.deepStrictEqual(actual.added, []);
assert.deepStrictEqual(actual.removed, []);
assert.deepStrictEqual(actual.updated, []);
assert.deepStrictEqual(actual.remote, expected);
});
});

200
src/vs/platform/userDataSync/test/common/globalStateMerge.test.ts
View File

@@ -15,10 +15,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when local and remote are same with multiple entries and local is not synced yet', async () => {
@@ -27,10 +27,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when local and remote are same with multiple entries in different order and local is not synced yet', async () => {
@@ -39,10 +39,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when local and remote are same with different base content', async () => {
@@ -52,10 +52,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when a new entry is added to remote and local has not synced yet', async () => {
@@ -64,10 +64,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, { 'b': { version: 1, value: 'b' } });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, { 'b': { version: 1, value: 'b' } });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when multiple new entries are added to remote and local is not synced yet', async () => {
@@ -76,10 +76,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, { 'b': { version: 1, value: 'b' }, 'a': { version: 1, value: 'a' } });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, { 'b': { version: 1, value: 'b' }, 'a': { version: 1, value: 'a' } });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when new entry is added to remote from base and local has not changed', async () => {
@@ -88,10 +88,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, { 'b': { version: 1, value: 'b' } });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, { 'b': { version: 1, value: 'b' } });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when an entry is removed from remote from base and local has not changed', async () => {
@@ -100,10 +100,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, ['b']);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, ['b']);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when all entries are removed from base and local has not changed', async () => {
@@ -112,10 +112,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, ['b', 'a']);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, ['b', 'a']);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when an entry is updated in remote from base and local has not changed', async () => {
@@ -124,10 +124,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, { 'a': { version: 1, value: 'b' } });
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, { 'a': { version: 1, value: 'b' } });
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when remote has moved forwarded with multiple changes and local stays with base', async () => {
@@ -136,10 +136,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, { 'c': { version: 1, value: 'c' } });
assert.deepEqual(actual.local.updated, { 'a': { version: 1, value: 'd' } });
assert.deepEqual(actual.local.removed, ['b']);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, { 'c': { version: 1, value: 'c' } });
assert.deepStrictEqual(actual.local.updated, { 'a': { version: 1, value: 'd' } });
assert.deepStrictEqual(actual.local.removed, ['b']);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when new entries are added to local and local is not synced yet', async () => {
@@ -148,10 +148,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when multiple new entries are added to local from base and remote is not changed', async () => {
@@ -160,10 +160,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, remote, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when an entry is removed from local from base and remote has not changed', async () => {
@@ -172,10 +172,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, remote, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when an entry is updated in local from base and remote has not changed', async () => {
@@ -184,10 +184,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, remote, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when local has moved forwarded with multiple changes and remote stays with base', async () => {
@@ -196,10 +196,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, remote, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when local and remote with one entry but different value and local is not synced yet', async () => {
@@ -208,10 +208,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, { 'a': { version: 1, value: 'b' } });
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, { 'a': { version: 1, value: 'b' } });
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when the entry is removed in remote but updated in local and a new entry is added in remote', async () => {
@@ -221,10 +221,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, { 'c': { version: 1, value: 'c' } });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, { 'a': { version: 1, value: 'a' }, 'c': { version: 1, value: 'c' }, 'b': { version: 1, value: 'd' } });
assert.deepStrictEqual(actual.local.added, { 'c': { version: 1, value: 'c' } });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, { 'a': { version: 1, value: 'a' }, 'c': { version: 1, value: 'c' }, 'b': { version: 1, value: 'd' } });
});
test('merge with single entry and local is empty', async () => {
@@ -234,10 +234,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when local and remote has moved forward with conflicts', async () => {
@@ -247,10 +247,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: [], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when a new entry is added to remote but scoped to machine locally and local is not synced yet', async () => {
@@ -259,10 +259,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, null, { machine: ['b'], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when an entry is updated to remote but scoped to machine locally', async () => {
@@ -271,10 +271,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, local, { machine: ['a'], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, null);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, null);
});
test('merge when a local value is removed and scoped to machine locally', async () => {
@@ -284,10 +284,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: ['b'], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge when local moved forwared by changing a key to machine scope', async () => {
@@ -297,10 +297,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: ['b'], unregistered: [] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, local);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, local);
});
test('merge should not remove remote keys if not registered', async () => {
@@ -310,10 +310,10 @@ suite('GlobalStateMerge', () => {
const actual = merge(local, remote, base, { machine: [], unregistered: ['c'] }, new NullLogService());
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.remote, { 'a': { version: 1, value: 'a' }, 'b': { version: 1, value: 'b' }, 'c': { version: 1, value: 'c' } });
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.remote, { 'a': { version: 1, value: 'a' }, 'b': { version: 1, value: 'b' }, 'c': { version: 1, value: 'c' } });
});
});

82
src/vs/platform/userDataSync/test/common/globalStateSync.test.ts
View File

@@ -37,30 +37,30 @@ suite('GlobalStateSync', () => {
teardown(() => disposableStore.clear());
test('when global state does not exist', async () => {
assert.deepEqual(await testObject.getLastSyncUserData(), null);
assert.deepStrictEqual(await testObject.getLastSyncUserData(), null);
let manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'GET', url: `${server.url}/v1/resource/${testObject.resource}/latest`, headers: {} },
]);
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(lastSyncUserData!.syncData, null);
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(lastSyncUserData!.syncData, null);
manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
test('when global state is created after first sync', async () => {
@@ -72,15 +72,15 @@ suite('GlobalStateSync', () => {
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': lastSyncUserData?.ref } },
]);
lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.deepEqual(JSON.parse(lastSyncUserData!.syncData!.content).storage, { 'a': { version: 1, value: 'value1' } });
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.deepStrictEqual(JSON.parse(lastSyncUserData!.syncData!.content).storage, { 'a': { version: 1, value: 'value1' } });
});
test('first time sync - outgoing to server (no state)', async () => {
@@ -89,13 +89,13 @@ suite('GlobalStateSync', () => {
await updateLocale(testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'globalState.argv.locale': { version: 1, value: 'en' }, 'a': { version: 1, value: 'value1' } });
assert.deepStrictEqual(actual.storage, { 'globalState.argv.locale': { version: 1, value: 'en' }, 'a': { version: 1, value: 'value1' } });
});
test('first time sync - incoming from server (no state)', async () => {
@@ -104,11 +104,11 @@ suite('GlobalStateSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value1');
assert.equal(await readLocale(testClient), 'en');
assert.strictEqual(readStorage('a', testClient), 'value1');
assert.strictEqual(await readLocale(testClient), 'en');
});
test('first time sync when storage exists', async () => {
@@ -117,16 +117,16 @@ suite('GlobalStateSync', () => {
updateUserStorage('b', 'value2', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value1');
assert.equal(readStorage('b', testClient), 'value2');
assert.strictEqual(readStorage('a', testClient), 'value1');
assert.strictEqual(readStorage('b', testClient), 'value2');
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'a': { version: 1, value: 'value1' }, 'b': { version: 1, value: 'value2' } });
assert.deepStrictEqual(actual.storage, { 'a': { version: 1, value: 'value1' }, 'b': { version: 1, value: 'value2' } });
});
test('first time sync when storage exists - has conflicts', async () => {
@@ -136,15 +136,15 @@ suite('GlobalStateSync', () => {
updateUserStorage('a', 'value2', client2);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value1');
assert.strictEqual(readStorage('a', testClient), 'value1');
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'a': { version: 1, value: 'value1' } });
assert.deepStrictEqual(actual.storage, { 'a': { version: 1, value: 'value1' } });
});
test('sync adding a storage value', async () => {
@@ -153,16 +153,16 @@ suite('GlobalStateSync', () => {
updateUserStorage('b', 'value2', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value1');
assert.equal(readStorage('b', testClient), 'value2');
assert.strictEqual(readStorage('a', testClient), 'value1');
assert.strictEqual(readStorage('b', testClient), 'value2');
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'a': { version: 1, value: 'value1' }, 'b': { version: 1, value: 'value2' } });
assert.deepStrictEqual(actual.storage, { 'a': { version: 1, value: 'value1' }, 'b': { version: 1, value: 'value2' } });
});
test('sync updating a storage value', async () => {
@@ -171,15 +171,15 @@ suite('GlobalStateSync', () => {
updateUserStorage('a', 'value2', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value2');
assert.strictEqual(readStorage('a', testClient), 'value2');
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'a': { version: 1, value: 'value2' } });
assert.deepStrictEqual(actual.storage, { 'a': { version: 1, value: 'value2' } });
});
test('sync removing a storage value', async () => {
@@ -189,16 +189,16 @@ suite('GlobalStateSync', () => {
removeStorage('b', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
assert.equal(readStorage('a', testClient), 'value1');
assert.equal(readStorage('b', testClient), undefined);
assert.strictEqual(readStorage('a', testClient), 'value1');
assert.strictEqual(readStorage('b', testClient), undefined);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseGlobalState(content!);
assert.deepEqual(actual.storage, { 'a': { version: 1, value: 'value1' } });
assert.deepStrictEqual(actual.storage, { 'a': { version: 1, value: 'value1' } });
});
function parseGlobalState(content: string): IGlobalState {

62
src/vs/platform/userDataSync/test/common/keybindingsMerge.test.ts
View File

@@ -15,7 +15,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote are same with similar when contexts', async () => {
@@ -24,7 +24,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote has entries in different order', async () => {
@@ -39,7 +39,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote are same with multiple entries', async () => {
@@ -56,7 +56,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote are same with different base content', async () => {
@@ -77,7 +77,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote are same with multiple entries in different order', async () => {
@@ -94,7 +94,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local and remote are same when remove entry is in different order', async () => {
@@ -111,7 +111,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(!actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when a new entry is added to remote', async () => {
@@ -127,7 +127,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when multiple new entries are added to remote', async () => {
@@ -144,7 +144,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when multiple new entries are added to remote from base and local has not changed', async () => {
@@ -161,7 +161,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when an entry is removed from remote from base and local has not changed', async () => {
@@ -177,7 +177,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when an entry (same command) is removed from remote from base and local has not changed', async () => {
@@ -191,7 +191,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when an entry is updated in remote from base and local has not changed', async () => {
@@ -204,7 +204,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when a command with multiple entries is updated from remote from base and local has not changed', async () => {
@@ -223,7 +223,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when remote has moved forwareded with multiple changes and local stays with base', async () => {
@@ -246,7 +246,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, localContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, remoteContent);
assert.strictEqual(actual.mergeContent, remoteContent);
});
test('merge when a new entry is added to local', async () => {
@@ -262,7 +262,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when multiple new entries are added to local', async () => {
@@ -279,7 +279,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when multiple new entries are added to local from base and remote is not changed', async () => {
@@ -296,7 +296,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when an entry is removed from local from base and remote has not changed', async () => {
@@ -312,7 +312,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when an entry (with same command) is removed from local from base and remote has not changed', async () => {
@@ -326,7 +326,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when an entry is updated in local from base and remote has not changed', async () => {
@@ -339,7 +339,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when a command with multiple entries is updated from local from base and remote has not changed', async () => {
@@ -358,7 +358,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, localContent);
assert.strictEqual(actual.mergeContent, localContent);
});
test('merge when local has moved forwareded with multiple changes and remote stays with base', async () => {
@@ -390,7 +390,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, remoteContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, expected);
assert.strictEqual(actual.mergeContent, expected);
});
test('merge when local and remote has moved forwareded with conflicts', async () => {
@@ -431,7 +431,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(!actual.hasConflicts);
assert.equal(actual.mergeContent, expected);
assert.strictEqual(actual.mergeContent, expected);
});
test('merge when local and remote with one entry but different value', async () => {
@@ -440,7 +440,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+d",
@@ -462,7 +462,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, null);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+d",
@@ -484,7 +484,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[]`);
});
@@ -495,7 +495,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+b",
@@ -511,7 +511,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+c",
@@ -528,7 +528,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+c",
@@ -571,7 +571,7 @@ suite('KeybindingsMerge - No Conflicts', () => {
const actual = await mergeKeybindings(localContent, remoteContent, baseContent);
assert.ok(actual.hasChanges);
assert.ok(actual.hasConflicts);
assert.equal(actual.mergeContent,
assert.strictEqual(actual.mergeContent,
`[
{
"key": "alt+d",

54
src/vs/platform/userDataSync/test/common/keybindingsSync.test.ts
View File

@@ -34,31 +34,31 @@ suite('KeybindingsSync', () => {
const fileService = client.instantiationService.get(IFileService);
const keybindingsResource = client.instantiationService.get(IEnvironmentService).keybindingsResource;
assert.deepEqual(await testObject.getLastSyncUserData(), null);
assert.deepStrictEqual(await testObject.getLastSyncUserData(), null);
let manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'GET', url: `${server.url}/v1/resource/${testObject.resource}/latest`, headers: {} },
]);
assert.ok(!await fileService.exists(keybindingsResource));
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(lastSyncUserData!.syncData, null);
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(lastSyncUserData!.syncData, null);
manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
test('when keybindings file is empty and remote has no changes', async () => {
@@ -70,9 +70,9 @@ suite('KeybindingsSync', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), '[]');
assert.equal(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), '[]');
assert.equal((await fileService.readFile(keybindingsResource)).value.toString(), '');
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), '[]');
assert.strictEqual(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), '[]');
assert.strictEqual((await fileService.readFile(keybindingsResource)).value.toString(), '');
});
test('when keybindings file is empty and remote has changes', async () => {
@@ -95,9 +95,9 @@ suite('KeybindingsSync', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.equal(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.equal((await fileService.readFile(keybindingsResource)).value.toString(), content);
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.strictEqual(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.strictEqual((await fileService.readFile(keybindingsResource)).value.toString(), content);
});
test('when keybindings file is empty with comment and remote has no changes', async () => {
@@ -110,9 +110,9 @@ suite('KeybindingsSync', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), expectedContent);
assert.equal(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), expectedContent);
assert.equal((await fileService.readFile(keybindingsResource)).value.toString(), expectedContent);
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), expectedContent);
assert.strictEqual(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), expectedContent);
assert.strictEqual((await fileService.readFile(keybindingsResource)).value.toString(), expectedContent);
});
test('when keybindings file is empty and remote has keybindings', async () => {
@@ -135,9 +135,9 @@ suite('KeybindingsSync', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.equal(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.equal((await fileService.readFile(keybindingsResource)).value.toString(), content);
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.strictEqual(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.strictEqual((await fileService.readFile(keybindingsResource)).value.toString(), content);
});
test('when keybindings file is empty and remote has empty array', async () => {
@@ -159,9 +159,9 @@ suite('KeybindingsSync', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.equal(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.equal((await fileService.readFile(keybindingsResource)).value.toString(), expectedLocalContent);
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), content);
assert.strictEqual(getKeybindingsContentFromSyncContent(remoteUserData!.syncData!.content!, true), content);
assert.strictEqual((await fileService.readFile(keybindingsResource)).value.toString(), expectedLocalContent);
});
test('when keybindings file is created after first sync', async () => {
@@ -175,15 +175,15 @@ suite('KeybindingsSync', () => {
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': lastSyncUserData?.ref } },
]);
lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), '[]');
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(getKeybindingsContentFromSyncContent(lastSyncUserData!.syncData!.content!, true), '[]');
});
test('test apply remote when keybindings file does not exist', async () => {
@@ -199,7 +199,7 @@ suite('KeybindingsSync', () => {
const content = await testObject.resolveContent(preview.resourcePreviews[0].remoteResource);
await testObject.accept(preview.resourcePreviews[0].remoteResource, content);
await testObject.apply(false);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
});

290
src/vs/platform/userDataSync/test/common/settingsMerge.test.ts
View File

@@ -15,9 +15,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({ 'a': 1 });
const remoteContent = stringify({ 'a': 1 });
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -31,9 +31,9 @@ suite('SettingsMerge - Merge', () => {
'b': 2
});
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -47,10 +47,10 @@ suite('SettingsMerge - Merge', () => {
'b': 2
});
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, localContent);
assert.equal(actual.remoteContent, remoteContent);
assert.strictEqual(actual.localContent, localContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.ok(actual.hasConflicts);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.conflictsSettings.length, 0);
});
test('merge when local and remote are same with different base content', async () => {
@@ -67,9 +67,9 @@ suite('SettingsMerge - Merge', () => {
'b': 2
});
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, localContent);
assert.equal(actual.remoteContent, remoteContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, localContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(actual.hasConflicts);
});
@@ -82,9 +82,9 @@ suite('SettingsMerge - Merge', () => {
'b': 2
});
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -98,9 +98,9 @@ suite('SettingsMerge - Merge', () => {
'c': 3,
});
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -114,9 +114,9 @@ suite('SettingsMerge - Merge', () => {
'c': 3,
});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -129,9 +129,9 @@ suite('SettingsMerge - Merge', () => {
'a': 1,
});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -141,9 +141,9 @@ suite('SettingsMerge - Merge', () => {
});
const remoteContent = stringify({});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -155,9 +155,9 @@ suite('SettingsMerge - Merge', () => {
'a': 2
});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -172,9 +172,9 @@ suite('SettingsMerge - Merge', () => {
'd': 4,
});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -191,9 +191,9 @@ suite('SettingsMerge - Merge', () => {
'b': 2,
});
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -213,9 +213,9 @@ suite('SettingsMerge - Merge', () => {
"c": 1,
}`;
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -235,9 +235,9 @@ suite('SettingsMerge - Merge', () => {
"b": 2,
}`;
const actual = merge(localContent, remoteContent, localContent, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -252,9 +252,9 @@ suite('SettingsMerge - Merge', () => {
'a': 1,
});
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -269,9 +269,9 @@ suite('SettingsMerge - Merge', () => {
'a': 1,
});
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -287,9 +287,9 @@ suite('SettingsMerge - Merge', () => {
'd': 4,
});
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -303,9 +303,9 @@ suite('SettingsMerge - Merge', () => {
'c': 2,
});
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -320,9 +320,9 @@ suite('SettingsMerge - Merge', () => {
'a': 1,
});
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -338,9 +338,9 @@ suite('SettingsMerge - Merge', () => {
"b": 2,
}`;
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -360,9 +360,9 @@ suite('SettingsMerge - Merge', () => {
"c": 1,
}`;
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -382,9 +382,9 @@ suite('SettingsMerge - Merge', () => {
"c": 1,
}`;
const actual = merge(localContent, remoteContent, remoteContent, [], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, localContent);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, localContent);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -397,10 +397,10 @@ suite('SettingsMerge - Merge', () => {
});
const expectedConflicts: IConflictSetting[] = [{ key: 'a', localValue: 1, remoteValue: 2 }];
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, localContent);
assert.equal(actual.remoteContent, remoteContent);
assert.strictEqual(actual.localContent, localContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
});
test('merge when the entry is removed in remote but updated in local and a new entry is added in remote', async () => {
@@ -415,13 +415,13 @@ suite('SettingsMerge - Merge', () => {
});
const expectedConflicts: IConflictSetting[] = [{ key: 'a', localValue: 2, remoteValue: undefined }];
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 2,
'b': 2
}));
assert.equal(actual.remoteContent, remoteContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
});
test('merge with single entry and local is empty', async () => {
@@ -434,10 +434,10 @@ suite('SettingsMerge - Merge', () => {
});
const expectedConflicts: IConflictSetting[] = [{ key: 'a', localValue: undefined, remoteValue: 2 }];
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, localContent);
assert.equal(actual.remoteContent, remoteContent);
assert.strictEqual(actual.localContent, localContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
});
test('merge when local and remote has moved forwareded with conflicts', async () => {
@@ -467,14 +467,14 @@ suite('SettingsMerge - Merge', () => {
{ key: 'e', localValue: 4, remoteValue: 5 },
];
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 2,
'c': 3,
'd': 5,
'e': 4,
'f': 1,
}));
assert.equal(actual.remoteContent, stringify({
assert.strictEqual(actual.remoteContent, stringify({
'b': 3,
'c': 3,
'd': 6,
@@ -482,7 +482,7 @@ suite('SettingsMerge - Merge', () => {
'f': 1,
}));
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
});
test('merge when local and remote has moved forwareded with change in order', async () => {
@@ -505,20 +505,20 @@ suite('SettingsMerge - Merge', () => {
'c': 4,
});
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 2,
'c': 4,
'b': 2,
'e': 5,
}));
assert.equal(actual.remoteContent, stringify({
assert.strictEqual(actual.remoteContent, stringify({
'a': 2,
'b': 2,
'e': 5,
'c': 4,
}));
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, []);
assert.deepStrictEqual(actual.conflictsSettings, []);
});
test('merge when local and remote has moved forwareded with comment changes', async () => {
@@ -544,10 +544,10 @@ suite('SettingsMerge - Merge', () => {
"c": 1
}`;
const actual = merge(localContent, remoteContent, baseContent, [], [], formattingOptions);
assert.equal(actual.localContent, localContent);
assert.equal(actual.remoteContent, remoteContent);
assert.strictEqual(actual.localContent, localContent);
assert.strictEqual(actual.remoteContent, remoteContent);
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, []);
assert.deepStrictEqual(actual.conflictsSettings, []);
});
test('resolve when local and remote has moved forwareded with resolved conflicts', async () => {
@@ -574,14 +574,14 @@ suite('SettingsMerge - Merge', () => {
{ key: 'd', localValue: 5, remoteValue: 6 },
];
const actual = merge(localContent, remoteContent, baseContent, [], [{ key: 'a', value: 2 }, { key: 'b', value: undefined }, { key: 'e', value: 5 }], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 2,
'c': 3,
'd': 5,
'e': 5,
'f': 1,
}));
assert.equal(actual.remoteContent, stringify({
assert.strictEqual(actual.remoteContent, stringify({
'c': 3,
'd': 6,
'e': 5,
@@ -589,16 +589,16 @@ suite('SettingsMerge - Merge', () => {
'a': 2,
}));
assert.ok(actual.hasConflicts);
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
});
test('ignored setting is not merged when changed in local and remote', async () => {
const localContent = stringify({ 'a': 1 });
const remoteContent = stringify({ 'a': 2 });
const actual = merge(localContent, remoteContent, null, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -607,9 +607,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({ 'a': 1 });
const remoteContent = stringify({ 'a': 2 });
const actual = merge(localContent, remoteContent, baseContent, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -617,9 +617,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({});
const remoteContent = stringify({ 'a': 1 });
const actual = merge(localContent, remoteContent, null, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -627,9 +627,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({ 'b': 2 });
const remoteContent = stringify({ 'a': 1, 'b': 2 });
const actual = merge(localContent, remoteContent, localContent, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -637,9 +637,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({ 'a': 1 });
const remoteContent = stringify({});
const actual = merge(localContent, remoteContent, null, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -647,9 +647,9 @@ suite('SettingsMerge - Merge', () => {
const localContent = stringify({ 'a': 2 });
const remoteContent = stringify({});
const actual = merge(localContent, remoteContent, localContent, ['a'], [], formattingOptions);
assert.equal(actual.localContent, null);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, null);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -673,16 +673,16 @@ suite('SettingsMerge - Merge', () => {
'e': 6,
});
const actual = merge(localContent, remoteContent, baseContent, ['a', 'e'], [], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 1,
'b': 3,
}));
assert.equal(actual.remoteContent, stringify({
assert.strictEqual(actual.remoteContent, stringify({
'a': 3,
'b': 3,
'e': 6,
}));
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
@@ -710,17 +710,17 @@ suite('SettingsMerge - Merge', () => {
{ key: 'b', localValue: 4, remoteValue: 3 },
];
const actual = merge(localContent, remoteContent, baseContent, ['a', 'e'], [], formattingOptions);
assert.equal(actual.localContent, stringify({
assert.strictEqual(actual.localContent, stringify({
'a': 1,
'b': 4,
'd': 5,
}));
assert.equal(actual.remoteContent, stringify({
assert.strictEqual(actual.remoteContent, stringify({
'a': 3,
'b': 3,
'e': 6,
}));
assert.deepEqual(actual.conflictsSettings, expectedConflicts);
assert.deepStrictEqual(actual.conflictsSettings, expectedConflicts);
assert.ok(actual.hasConflicts);
});
@@ -735,9 +735,9 @@ suite('SettingsMerge - Merge', () => {
"a": 1,
}`;
const actual = merge(localContent, remoteContent, null, [], [], formattingOptions);
assert.equal(actual.localContent, remoteContent);
assert.equal(actual.remoteContent, null);
assert.equal(actual.conflictsSettings.length, 0);
assert.strictEqual(actual.localContent, remoteContent);
assert.strictEqual(actual.remoteContent, null);
assert.strictEqual(actual.conflictsSettings.length, 0);
assert.ok(!actual.hasConflicts);
});
});
@@ -757,7 +757,7 @@ suite('SettingsMerge - Compute Remote Content', () => {
'e': 6,
});
const actual = updateIgnoredSettings(localContent, remoteContent, [], formattingOptions);
assert.equal(actual, localContent);
assert.strictEqual(actual, localContent);
});
test('ignored settings are not updated from remote content', async () => {
@@ -778,7 +778,7 @@ suite('SettingsMerge - Compute Remote Content', () => {
'c': 3,
});
const actual = updateIgnoredSettings(localContent, remoteContent, ['a'], formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
});
@@ -808,7 +808,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting without comments at the end', () => {
@@ -832,7 +832,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert between settings without comment', () => {
@@ -858,7 +858,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert between settings and there is a comment in between in source', () => {
@@ -885,7 +885,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting and after a comment at the end', () => {
@@ -911,7 +911,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting ending with comma and after a comment at the end', () => {
@@ -937,7 +937,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a comment and there are no settings', () => {
@@ -960,7 +960,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting and between a comment and setting', () => {
@@ -989,7 +989,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting between two comments and there is a setting after', () => {
@@ -1021,7 +1021,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting between two comments on the same line and there is a setting after', () => {
@@ -1051,7 +1051,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting between two line comments on the same line and there is a setting after', () => {
@@ -1081,7 +1081,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting between two comments and there is no setting after', () => {
@@ -1110,7 +1110,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting with comma and between two comments and there is no setting after', () => {
@@ -1139,7 +1139,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting without comments', () => {
@@ -1164,7 +1164,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting without comments at the end', () => {
@@ -1188,7 +1188,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting with comment', () => {
@@ -1215,7 +1215,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting and before a comment at the beginning', () => {
@@ -1241,7 +1241,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting ending with comma and before a comment at the begninning', () => {
@@ -1267,7 +1267,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting and between a setting and comment', () => {
@@ -1296,7 +1296,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting between two comments and there is a setting before', () => {
@@ -1328,7 +1328,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting between two comments on the same line and there is a setting before', () => {
@@ -1359,7 +1359,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting between two line comments on the same line and there is a setting before', () => {
@@ -1389,7 +1389,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting between two comments and there is no setting before', () => {
@@ -1418,7 +1418,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert before a setting with comma and between two comments and there is no setting before', () => {
@@ -1447,7 +1447,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a setting that is of object type', () => {
@@ -1470,7 +1470,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('a', sourceContent, targetContent, formattingOptions);
assert.equal(actual, sourceContent);
assert.strictEqual(actual, sourceContent);
});
test('Insert after a setting that is of array type', () => {
@@ -1493,7 +1493,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('a', sourceContent, targetContent, formattingOptions);
assert.equal(actual, sourceContent);
assert.strictEqual(actual, sourceContent);
});
test('Insert after a comment with comma separator of previous setting and no next nodes ', () => {
@@ -1522,7 +1522,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a comment with comma separator of previous setting and there is a setting after ', () => {
@@ -1554,7 +1554,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
test('Insert after a comment with comma separator of previous setting and there is a comment after ', () => {
@@ -1586,7 +1586,7 @@ suite('SettingsMerge - Add Setting', () => {
const actual = addSetting('b', sourceContent, targetContent, formattingOptions);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
});

62
src/vs/platform/userDataSync/test/common/settingsSync.test.ts
View File

@@ -52,31 +52,31 @@ suite('SettingsSync - Auto', () => {
const fileService = client.instantiationService.get(IFileService);
const settingResource = client.instantiationService.get(IEnvironmentService).settingsResource;
assert.deepEqual(await testObject.getLastSyncUserData(), null);
assert.deepStrictEqual(await testObject.getLastSyncUserData(), null);
let manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'GET', url: `${server.url}/v1/resource/${testObject.resource}/latest`, headers: {} },
]);
assert.ok(!await fileService.exists(settingResource));
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(lastSyncUserData!.syncData, null);
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(lastSyncUserData!.syncData, null);
manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
manifest = await client.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
test('when settings file is empty and remote has no changes', async () => {
@@ -88,9 +88,9 @@ suite('SettingsSync - Auto', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, '{}');
assert.equal(parseSettingsSyncContent(remoteUserData!.syncData!.content!)?.settings, '{}');
assert.equal((await fileService.readFile(settingsResource)).value.toString(), '');
assert.strictEqual(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, '{}');
assert.strictEqual(parseSettingsSyncContent(remoteUserData!.syncData!.content!)?.settings, '{}');
assert.strictEqual((await fileService.readFile(settingsResource)).value.toString(), '');
});
test('when settings file is empty and remote has changes', async () => {
@@ -129,9 +129,9 @@ suite('SettingsSync - Auto', () => {
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.equal(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, content);
assert.equal(parseSettingsSyncContent(remoteUserData!.syncData!.content!)?.settings, content);
assert.equal((await fileService.readFile(settingsResource)).value.toString(), content);
assert.strictEqual(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, content);
assert.strictEqual(parseSettingsSyncContent(remoteUserData!.syncData!.content!)?.settings, content);
assert.strictEqual((await fileService.readFile(settingsResource)).value.toString(), content);
});
test('when settings file is created after first sync', async () => {
@@ -146,15 +146,15 @@ suite('SettingsSync - Auto', () => {
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': lastSyncUserData?.ref } },
]);
lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, '{}');
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(parseSettingsSyncContent(lastSyncUserData!.syncData!.content!)?.settings, '{}');
});
test('sync for first time to the server', async () => {
@@ -187,7 +187,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, expected);
assert.deepStrictEqual(actual, expected);
});
test('do not sync machine settings', async () => {
@@ -211,7 +211,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
"files.simpleDialog.enable": true,
@@ -242,7 +242,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
"files.simpleDialog.enable": true,
@@ -273,7 +273,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
@@ -297,7 +297,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
}`);
});
@@ -315,7 +315,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
,
}`);
});
@@ -367,7 +367,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
"files.simpleDialog.enable": true,
@@ -415,7 +415,7 @@ suite('SettingsSync - Auto', () => {
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
"files.simpleDialog.enable": true,
@@ -462,7 +462,7 @@ suite('SettingsSync - Auto', () => {
assert.fail('should fail with invalid content error');
} catch (e) {
assert.ok(e instanceof UserDataSyncError);
assert.deepEqual((<UserDataSyncError>e).code, UserDataSyncErrorCode.LocalInvalidContent);
assert.deepStrictEqual((<UserDataSyncError>e).code, UserDataSyncErrorCode.LocalInvalidContent);
}
});
@@ -483,12 +483,12 @@ suite('SettingsSync - Auto', () => {
}), client);
await testObject.sync(await client.manifest());
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.equal(testObject.conflicts[0].localResource.toString(), testObject.localResource);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.conflicts[0].localResource.toString(), testObject.localResource.toString());
const fileService = client.instantiationService.get(IFileService);
const mergeContent = (await fileService.readFile(testObject.conflicts[0].previewResource)).value.toString();
assert.deepEqual(JSON.parse(mergeContent), {
assert.deepStrictEqual(JSON.parse(mergeContent), {
'b': 1,
'settingsSync.ignoredSettings': ['a']
});
@@ -537,14 +537,14 @@ suite('SettingsSync - Manual', () => {
await updateSettings(settingsContent, client);
let preview = await testObject.preview(await client.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
const { content } = await client.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSettings(content!);
assert.deepEqual(actual, `{
assert.deepStrictEqual(actual, `{
// Always
"files.autoSave": "afterDelay",
"files.simpleDialog.enable": true,

294
src/vs/platform/userDataSync/test/common/snippetsMerge.test.ts
View File

@@ -116,13 +116,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local and remote are same with multiple entries', async () => {
@@ -131,13 +131,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local and remote are same with multiple entries in different order', async () => {
@@ -146,13 +146,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local and remote are same with different base content', async () => {
@@ -162,13 +162,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, base);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when a new entry is added to remote', async () => {
@@ -177,13 +177,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when multiple new entries are added to remote', async () => {
@@ -192,13 +192,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, remote);
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, remote);
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when new entry is added to remote from base and local has not changed', async () => {
@@ -207,13 +207,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, local);
assert.deepEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when an entry is removed from remote from base and local has not changed', async () => {
@@ -222,13 +222,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, local);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, ['typescript.json']);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, ['typescript.json']);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when all entries are removed from base and local has not changed', async () => {
@@ -237,13 +237,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, local);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, ['html.json', 'typescript.json']);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, ['html.json', 'typescript.json']);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when an entry is updated in remote from base and local has not changed', async () => {
@@ -252,13 +252,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, local);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, { 'html.json': htmlSnippet2 });
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when remote has moved forwarded with multiple changes and local stays with base', async () => {
@@ -267,13 +267,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, local);
assert.deepEqual(actual.local.added, { 'c.json': cSnippet });
assert.deepEqual(actual.local.updated, { 'html.json': htmlSnippet2 });
assert.deepEqual(actual.local.removed, ['typescript.json']);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'c.json': cSnippet });
assert.deepStrictEqual(actual.local.updated, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual.local.removed, ['typescript.json']);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when a new entries are added to local', async () => {
@@ -282,13 +282,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when multiple new entries are added to local from base and remote is not changed', async () => {
@@ -297,13 +297,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, remote);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, { 'html.json': htmlSnippet1, 'c.json': cSnippet });
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, { 'html.json': htmlSnippet1, 'c.json': cSnippet });
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when an entry is removed from local from base and remote has not changed', async () => {
@@ -312,13 +312,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, remote);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, ['typescript.json']);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, ['typescript.json']);
});
test('merge when an entry is updated in local from base and remote has not changed', async () => {
@@ -327,13 +327,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, remote);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, { 'html.json': htmlSnippet2 });
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local has moved forwarded with multiple changes and remote stays with base', async () => {
@@ -342,13 +342,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, remote);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepEqual(actual.remote.updated, { 'html.json': htmlSnippet2 });
assert.deepEqual(actual.remote.removed, ['typescript.json']);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepStrictEqual(actual.remote.updated, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual.remote.removed, ['typescript.json']);
});
test('merge when local and remote with one entry but different value', async () => {
@@ -357,13 +357,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, null);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, ['html.json']);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, ['html.json']);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when the entry is removed in remote but updated in local and a new entry is added in remote', async () => {
@@ -373,13 +373,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, base);
assert.deepEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, ['html.json']);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, ['html.json']);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge with single entry and local is empty', async () => {
@@ -389,13 +389,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, base);
assert.deepEqual(actual.local.added, { 'html.json': htmlSnippet2 });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, []);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, []);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local and remote has moved forwareded with conflicts', async () => {
@@ -405,13 +405,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, base);
assert.deepEqual(actual.local.added, { 'typescript.json': tsSnippet2 });
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, ['html.json']);
assert.deepEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, { 'typescript.json': tsSnippet2 });
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, ['html.json']);
assert.deepStrictEqual(actual.remote.added, { 'c.json': cSnippet });
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
test('merge when local and remote has moved forwareded with multiple conflicts', async () => {
@@ -421,13 +421,13 @@ suite('SnippetsMerge', () => {
const actual = merge(local, remote, base);
assert.deepEqual(actual.local.added, {});
assert.deepEqual(actual.local.updated, {});
assert.deepEqual(actual.local.removed, []);
assert.deepEqual(actual.conflicts, ['html.json', 'typescript.json']);
assert.deepEqual(actual.remote.added, {});
assert.deepEqual(actual.remote.updated, {});
assert.deepEqual(actual.remote.removed, []);
assert.deepStrictEqual(actual.local.added, {});
assert.deepStrictEqual(actual.local.updated, {});
assert.deepStrictEqual(actual.local.removed, []);
assert.deepStrictEqual(actual.conflicts, ['html.json', 'typescript.json']);
assert.deepStrictEqual(actual.remote.added, {});
assert.deepStrictEqual(actual.remote.updated, {});
assert.deepStrictEqual(actual.remote.removed, []);
});
});

266
src/vs/platform/userDataSync/test/common/snippetsSync.test.ts
View File

@@ -171,31 +171,31 @@ suite('SnippetsSync', () => {
const fileService = testClient.instantiationService.get(IFileService);
const snippetsResource = testClient.instantiationService.get(IEnvironmentService).snippetsHome;
assert.deepEqual(await testObject.getLastSyncUserData(), null);
assert.deepStrictEqual(await testObject.getLastSyncUserData(), null);
let manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'GET', url: `${server.url}/v1/resource/${testObject.resource}/latest`, headers: {} },
]);
assert.ok(!await fileService.exists(snippetsResource));
const lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.equal(lastSyncUserData!.syncData, null);
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.strictEqual(lastSyncUserData!.syncData, null);
manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
manifest = await testClient.manifest();
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
test('when snippet is created after first sync', async () => {
@@ -207,15 +207,15 @@ suite('SnippetsSync', () => {
server.reset();
await testObject.sync(manifest);
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': lastSyncUserData?.ref } },
]);
lastSyncUserData = await testObject.getLastSyncUserData();
const remoteUserData = await testObject.getRemoteUserData(null);
assert.deepEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.deepEqual(lastSyncUserData!.syncData!.content, JSON.stringify({ 'html.json': htmlSnippet1 }));
assert.deepStrictEqual(lastSyncUserData!.ref, remoteUserData.ref);
assert.deepStrictEqual(lastSyncUserData!.syncData, remoteUserData.syncData);
assert.deepStrictEqual(lastSyncUserData!.syncData!.content, JSON.stringify({ 'html.json': htmlSnippet1 }));
});
test('first time sync - outgoing to server (no snippets)', async () => {
@@ -223,13 +223,13 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet1, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
});
test('first time sync - incoming from server (no snippets)', async () => {
@@ -238,13 +238,13 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const actual2 = await readSnippet('typescript.json', testClient);
assert.equal(actual2, tsSnippet1);
assert.strictEqual(actual2, tsSnippet1);
});
test('first time sync when snippets exists', async () => {
@@ -253,18 +253,18 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet1, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const actual2 = await readSnippet('typescript.json', testClient);
assert.equal(actual2, tsSnippet1);
assert.strictEqual(actual2, tsSnippet1);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
});
test('first time sync when snippets exists - has conflicts', async () => {
@@ -274,7 +274,7 @@ suite('SnippetsSync', () => {
await updateSnippet('html.json', htmlSnippet2, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
const environmentService = testClient.instantiationService.get(IEnvironmentService);
const local = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json');
assertPreviews(testObject.conflicts, [local]);
@@ -290,16 +290,16 @@ suite('SnippetsSync', () => {
await testObject.accept(conflicts[0].previewResource, htmlSnippet1);
await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet1 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet1 });
});
test('first time sync when snippets exists - has multiple conflicts', async () => {
@@ -311,7 +311,7 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
const environmentService = testClient.instantiationService.get(IEnvironmentService);
const local1 = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json');
const local2 = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json');
@@ -331,7 +331,7 @@ suite('SnippetsSync', () => {
await testObject.accept(conflicts[0].previewResource, htmlSnippet2);
conflicts = testObject.conflicts;
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
const environmentService = testClient.instantiationService.get(IEnvironmentService);
const local = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json');
assertPreviews(testObject.conflicts, [local]);
@@ -351,18 +351,18 @@ suite('SnippetsSync', () => {
await testObject.accept(conflicts[1].previewResource, tsSnippet1);
await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet2);
assert.strictEqual(actual1, htmlSnippet2);
const actual2 = await readSnippet('typescript.json', testClient);
assert.equal(actual2, tsSnippet1);
assert.strictEqual(actual2, tsSnippet1);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet2, 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet2, 'typescript.json': tsSnippet1 });
});
test('sync adding a snippet', async () => {
@@ -371,18 +371,18 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet1, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const actual2 = await readSnippet('typescript.json', testClient);
assert.equal(actual2, tsSnippet1);
assert.strictEqual(actual2, tsSnippet1);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet1, 'typescript.json': tsSnippet1 });
});
test('sync adding a snippet - accept', async () => {
@@ -394,13 +394,13 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const actual2 = await readSnippet('typescript.json', testClient);
assert.equal(actual2, tsSnippet1);
assert.strictEqual(actual2, tsSnippet1);
});
test('sync updating a snippet', async () => {
@@ -409,16 +409,16 @@ suite('SnippetsSync', () => {
await updateSnippet('html.json', htmlSnippet2, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet2);
assert.strictEqual(actual1, htmlSnippet2);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet2 });
});
test('sync updating a snippet - accept', async () => {
@@ -430,11 +430,11 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet2);
assert.strictEqual(actual1, htmlSnippet2);
});
test('sync updating a snippet - conflict', async () => {
@@ -447,7 +447,7 @@ suite('SnippetsSync', () => {
await updateSnippet('html.json', htmlSnippet3, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
const environmentService = testClient.instantiationService.get(IEnvironmentService);
const local = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json');
assertPreviews(testObject.conflicts, [local]);
@@ -466,16 +466,16 @@ suite('SnippetsSync', () => {
await testObject.accept(testObject.conflicts[0].previewResource, htmlSnippet2);
await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet2);
assert.strictEqual(actual1, htmlSnippet2);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet2 });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet2 });
});
test('sync removing a snippet', async () => {
@@ -485,18 +485,18 @@ suite('SnippetsSync', () => {
await removeSnippet('html.json', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('html.json', testClient);
assert.equal(actual2, null);
assert.strictEqual(actual2, null);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'typescript.json': tsSnippet1 });
});
test('sync removing a snippet - accept', async () => {
@@ -509,13 +509,13 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('html.json', testClient);
assert.equal(actual2, null);
assert.strictEqual(actual2, null);
});
test('sync removing a snippet locally and updating it remotely', async () => {
@@ -530,13 +530,13 @@ suite('SnippetsSync', () => {
await removeSnippet('html.json', testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('html.json', testClient);
assert.equal(actual2, htmlSnippet2);
assert.strictEqual(actual2, htmlSnippet2);
});
test('sync removing a snippet - conflict', async () => {
@@ -551,7 +551,7 @@ suite('SnippetsSync', () => {
await updateSnippet('html.json', htmlSnippet2, testClient);
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
const environmentService = testClient.instantiationService.get(IEnvironmentService);
const local = joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json');
assertPreviews(testObject.conflicts, [local]);
@@ -571,18 +571,18 @@ suite('SnippetsSync', () => {
await testObject.accept(testObject.conflicts[0].previewResource, htmlSnippet3);
await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('html.json', testClient);
assert.equal(actual2, htmlSnippet3);
assert.strictEqual(actual2, htmlSnippet3);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'typescript.json': tsSnippet1, 'html.json': htmlSnippet3 });
assert.deepStrictEqual(actual, { 'typescript.json': tsSnippet1, 'html.json': htmlSnippet3 });
});
test('sync removing a snippet - resolve conflict by removing', async () => {
@@ -599,18 +599,18 @@ suite('SnippetsSync', () => {
await testObject.accept(testObject.conflicts[0].previewResource, null);
await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('html.json', testClient);
assert.equal(actual2, null);
assert.strictEqual(actual2, null);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'typescript.json': tsSnippet1 });
assert.deepStrictEqual(actual, { 'typescript.json': tsSnippet1 });
});
test('sync global and language snippet', async () => {
@@ -619,18 +619,18 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('html.json', testClient);
assert.equal(actual1, htmlSnippet1);
assert.strictEqual(actual1, htmlSnippet1);
const actual2 = await readSnippet('global.code-snippets', testClient);
assert.equal(actual2, globalSnippet);
assert.strictEqual(actual2, globalSnippet);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'html.json': htmlSnippet1, 'global.code-snippets': globalSnippet });
assert.deepStrictEqual(actual, { 'html.json': htmlSnippet1, 'global.code-snippets': globalSnippet });
});
test('sync should ignore non snippets', async () => {
@@ -640,20 +640,20 @@ suite('SnippetsSync', () => {
await client2.sync();
await testObject.sync(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
const actual1 = await readSnippet('typescript.json', testClient);
assert.equal(actual1, tsSnippet1);
assert.strictEqual(actual1, tsSnippet1);
const actual2 = await readSnippet('global.code-snippets', testClient);
assert.equal(actual2, globalSnippet);
assert.strictEqual(actual2, globalSnippet);
const actual3 = await readSnippet('html.html', testClient);
assert.equal(actual3, null);
assert.strictEqual(actual3, null);
const { content } = await testClient.read(testObject.resource);
assert.ok(content !== null);
const actual = parseSnippets(content!);
assert.deepEqual(actual, { 'typescript.json': tsSnippet1, 'global.code-snippets': globalSnippet });
assert.deepStrictEqual(actual, { 'typescript.json': tsSnippet1, 'global.code-snippets': globalSnippet });
});
test('previews are reset after all conflicts resolved', async () => {
@@ -679,23 +679,23 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('merge when there are multiple snippets and all snippets are merged', async () => {
@@ -705,24 +705,24 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
preview = await testObject.merge(preview!.resourcePreviews[1].localResource);
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('merge when there are multiple snippets and all snippets are merged and applied', async () => {
@@ -732,21 +732,21 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
preview = await testObject.merge(preview!.resourcePreviews[1].localResource);
preview = await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('merge when there are multiple snippets and one snippet has no changes and one snippet is merged', async () => {
@@ -759,23 +759,23 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('merge when there are multiple snippets and one snippet has no changes and one snippet is merged and applied', async () => {
@@ -788,20 +788,20 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('merge when there are multiple snippets with conflicts and only one snippet is merged', async () => {
@@ -815,17 +815,17 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
@@ -848,18 +848,18 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
preview = await testObject.merge(preview!.resourcePreviews[1].previewResource);
assert.equal(testObject.status, SyncStatus.HasConflicts);
assert.strictEqual(testObject.status, SyncStatus.HasConflicts);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
@@ -883,23 +883,23 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource, htmlSnippet2);
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('accept when there are multiple snippets with conflicts and all snippets are accepted', async () => {
@@ -913,24 +913,24 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource, htmlSnippet2);
preview = await testObject.accept(preview!.resourcePreviews[1].previewResource, tsSnippet2);
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('accept when there are multiple snippets with conflicts and all snippets are accepted and applied', async () => {
@@ -944,21 +944,21 @@ suite('SnippetsSync', () => {
await updateSnippet('typescript.json', tsSnippet2, testClient);
let preview = await testObject.preview(await testClient.manifest());
assert.equal(testObject.status, SyncStatus.Syncing);
assert.strictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews,
[
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'html.json'),
joinPath(environmentService.userDataSyncHome, testObject.resource, PREVIEW_DIR_NAME, 'typescript.json'),
]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource, htmlSnippet2);
preview = await testObject.accept(preview!.resourcePreviews[1].previewResource, tsSnippet2);
preview = await testObject.apply(false);
assert.equal(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepEqual(testObject.conflicts, []);
assert.strictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assert.deepStrictEqual(testObject.conflicts, []);
});
function parseSnippets(content: string): IStringDictionary<string> {
@@ -992,7 +992,7 @@ suite('SnippetsSync', () => {
}
function assertPreviews(actual: IResourcePreview[], expected: URI[]) {
assert.deepEqual(actual.map(({ previewResource }) => previewResource.toString()), expected.map(uri => uri.toString()));
assert.deepStrictEqual(actual.map(({ previewResource }) => previewResource.toString()), expected.map(uri => uri.toString()));
}
});

282
src/vs/platform/userDataSync/test/common/synchronizer.test.ts
View File

@@ -28,20 +28,20 @@ class TestSynchroniser extends AbstractSynchroniser {
onDoSyncCall: Emitter<void> = this._register(new Emitter<void>());
failWhenGettingLatestRemoteUserData: boolean = false;
readonly resource: SyncResource = SyncResource.Settings;
override readonly resource: SyncResource = SyncResource.Settings;
protected readonly version: number = 1;
private cancelled: boolean = false;
readonly localResource = joinPath(this.environmentService.userRoamingDataHome, 'testResource.json');
protected getLatestRemoteUserData(manifest: IUserDataManifest | null, lastSyncUserData: IRemoteUserData | null): Promise<IRemoteUserData> {
protected override getLatestRemoteUserData(manifest: IUserDataManifest | null, lastSyncUserData: IRemoteUserData | null): Promise<IRemoteUserData> {
if (this.failWhenGettingLatestRemoteUserData) {
throw new Error();
}
return super.getLatestRemoteUserData(manifest, lastSyncUserData);
}
protected async doSync(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, apply: boolean): Promise<SyncStatus> {
protected override async doSync(remoteUserData: IRemoteUserData, lastSyncUserData: IRemoteUserData | null, apply: boolean): Promise<SyncStatus> {
this.cancelled = false;
this.onDoSyncCall.fire();
await this.syncBarrier.wait();
@@ -145,18 +145,18 @@ class TestSynchroniser extends AbstractSynchroniser {
await this.updateLastSyncUserData(remoteUserData);
}
async stop(): Promise<void> {
override async stop(): Promise<void> {
this.cancelled = true;
this.syncBarrier.open();
super.stop();
}
async triggerLocalChange(): Promise<void> {
override async triggerLocalChange(): Promise<void> {
super.triggerLocalChange();
}
onDidTriggerLocalChangeCall: Emitter<void> = this._register(new Emitter<void>());
protected async doTriggerLocalChange(): Promise<void> {
protected override async doTriggerLocalChange(): Promise<void> {
await super.doTriggerLocalChange();
this.onDidTriggerLocalChangeCall.fire();
}
@@ -191,8 +191,8 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.sync(await client.manifest());
await promise;
assert.deepEqual(actual, [SyncStatus.Syncing]);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(actual, [SyncStatus.Syncing]);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
testObject.stop();
});
@@ -205,8 +205,8 @@ suite('TestSynchronizer - Auto Sync', () => {
disposableStore.add(testObject.onDidChangeStatus(status => actual.push(status)));
await testObject.sync(await client.manifest());
assert.deepEqual(actual, [SyncStatus.Syncing, SyncStatus.Idle]);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(actual, [SyncStatus.Syncing, SyncStatus.Idle]);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
});
test('status is set correctly when sync has errors', async () => {
@@ -221,8 +221,8 @@ suite('TestSynchronizer - Auto Sync', () => {
await testObject.sync(await client.manifest());
assert.fail('Should fail');
} catch (e) {
assert.deepEqual(actual, [SyncStatus.Syncing, SyncStatus.Idle]);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(actual, [SyncStatus.Syncing, SyncStatus.Idle]);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
}
});
@@ -233,7 +233,7 @@ suite('TestSynchronizer - Auto Sync', () => {
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assertConflicts(testObject.conflicts, [testObject.localResource]);
});
@@ -248,8 +248,8 @@ suite('TestSynchronizer - Auto Sync', () => {
disposableStore.add(testObject.onDidChangeStatus(status => actual.push(status)));
await testObject.sync(await client.manifest());
assert.deepEqual(actual, []);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(actual, []);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
await testObject.stop();
});
@@ -263,8 +263,8 @@ suite('TestSynchronizer - Auto Sync', () => {
await testObject.sync(await client.manifest());
assert.deepEqual(actual, []);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(actual, []);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
});
test('sync should not run if there are conflicts', async () => {
@@ -277,8 +277,8 @@ suite('TestSynchronizer - Auto Sync', () => {
disposableStore.add(testObject.onDidChangeStatus(status => actual.push(status)));
await testObject.sync(await client.manifest());
assert.deepEqual(actual, []);
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(actual, []);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
});
test('accept preview during conflicts', async () => {
@@ -287,16 +287,16 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncBarrier.open();
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
const fileService = client.instantiationService.get(IFileService);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, (await fileService.readFile(testObject.localResource)).value.toString());
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, (await fileService.readFile(testObject.localResource)).value.toString());
});
test('accept remote during conflicts', async () => {
@@ -310,16 +310,16 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, currentRemoteContent);
assert.equal((await fileService.readFile(testObject.localResource)).value.toString(), currentRemoteContent);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, currentRemoteContent);
assert.strictEqual((await fileService.readFile(testObject.localResource)).value.toString(), currentRemoteContent);
});
test('accept local during conflicts', async () => {
@@ -332,16 +332,16 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].localResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, newLocalContent);
assert.equal((await fileService.readFile(testObject.localResource)).value.toString(), newLocalContent);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, newLocalContent);
assert.strictEqual((await fileService.readFile(testObject.localResource)).value.toString(), newLocalContent);
});
test('accept new content during conflicts', async () => {
@@ -354,17 +354,17 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
const mergeContent = 'newContent';
await testObject.accept(testObject.conflicts[0].previewResource, mergeContent);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, mergeContent);
assert.equal((await fileService.readFile(testObject.localResource)).value.toString(), mergeContent);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, mergeContent);
assert.strictEqual((await fileService.readFile(testObject.localResource)).value.toString(), mergeContent);
});
test('accept delete during conflicts', async () => {
@@ -377,15 +377,15 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].previewResource, null);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, '');
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, '');
assert.ok(!(await fileService.exists(testObject.localResource)));
});
@@ -398,15 +398,15 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].localResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, '');
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, '');
assert.ok(!(await fileService.exists(testObject.localResource)));
});
@@ -418,15 +418,15 @@ suite('TestSynchronizer - Auto Sync', () => {
testObject.syncResult = { hasConflicts: true, hasError: false };
await testObject.sync(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
await testObject.accept(testObject.conflicts[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertConflicts(testObject.conflicts, []);
await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal((await testObject.getRemoteUserData(null)).syncData, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData, null);
assert.ok(!(await fileService.exists(testObject.localResource)));
});
@@ -450,7 +450,7 @@ suite('TestSynchronizer - Auto Sync', () => {
const ref = manifest!.latest![testObject.resource];
await testObject.sync(await client.manifest());
assert.deepEqual(server.requests, [
assert.deepStrictEqual(server.requests, [
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': ref } },
{ type: 'GET', url: `${server.url}/v1/resource/${testObject.resource}/latest`, headers: {} },
{ type: 'POST', url: `${server.url}/v1/resource/${testObject.resource}`, headers: { 'If-Match': `${parseInt(ref) + 1}` } },
@@ -467,7 +467,7 @@ suite('TestSynchronizer - Auto Sync', () => {
await testObject.triggerLocalChange();
await promise;
assert.deepEqual(server.requests, []);
assert.deepStrictEqual(server.requests, []);
});
test('status is reset when getting latest remote data fails', async () => {
@@ -480,7 +480,7 @@ suite('TestSynchronizer - Auto Sync', () => {
} catch (error) {
}
assert.equal(testObject.status, SyncStatus.Idle);
assert.strictEqual(testObject.status, SyncStatus.Idle);
});
});
@@ -508,7 +508,7 @@ suite('TestSynchronizer - Manual Sync', () => {
const preview = await testObject.preview(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assertConflicts(testObject.conflicts, []);
});
@@ -521,9 +521,9 @@ suite('TestSynchronizer - Manual Sync', () => {
let preview = await testObject.preview(await client.manifest());
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -535,9 +535,9 @@ suite('TestSynchronizer - Manual Sync', () => {
let preview = await testObject.preview(await client.manifest());
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -550,9 +550,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -567,13 +567,13 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
const expectedContent = manifest!.latest![testObject.resource];
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preview -> accept -> apply', async () => {
@@ -588,12 +588,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preview -> merge -> accept -> apply', async () => {
@@ -608,12 +608,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal(!(await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preview -> accept', async () => {
@@ -624,7 +624,7 @@ suite('TestSynchronizer - Manual Sync', () => {
let preview = await testObject.preview(await client.manifest());
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assertConflicts(testObject.conflicts, []);
});
@@ -641,12 +641,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preivew -> merge -> discard', async () => {
@@ -658,9 +658,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -674,9 +674,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -689,9 +689,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -705,9 +705,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -721,9 +721,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.merge(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -737,9 +737,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -756,11 +756,11 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal(!(await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preivew -> accept -> discard -> accept -> apply', async () => {
@@ -777,11 +777,11 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal(!(await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('preivew -> accept -> discard -> merge -> apply', async () => {
@@ -799,12 +799,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.merge(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('conflicts: preview', async () => {
@@ -814,7 +814,7 @@ suite('TestSynchronizer - Manual Sync', () => {
const preview = await testObject.preview(await client.manifest());
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assertConflicts(testObject.conflicts, []);
});
@@ -827,9 +827,9 @@ suite('TestSynchronizer - Manual Sync', () => {
let preview = await testObject.preview(await client.manifest());
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assertConflicts(testObject.conflicts, [preview!.resourcePreviews[0].localResource]);
});
@@ -842,9 +842,9 @@ suite('TestSynchronizer - Manual Sync', () => {
await testObject.merge(preview!.resourcePreviews[0].previewResource);
await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -858,9 +858,9 @@ suite('TestSynchronizer - Manual Sync', () => {
const content = await testObject.resolveContent(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource, content);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('conflicts: preview -> merge -> accept -> apply', async () => {
@@ -878,12 +878,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('conflicts: preview -> accept', async () => {
@@ -895,7 +895,7 @@ suite('TestSynchronizer - Manual Sync', () => {
const content = await testObject.resolveContent(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource, content);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assertConflicts(testObject.conflicts, []);
});
@@ -914,12 +914,12 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('conflicts: preivew -> merge -> discard', async () => {
@@ -931,9 +931,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.merge(preview!.resourcePreviews[0].previewResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -947,9 +947,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -962,9 +962,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].previewResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -978,9 +978,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Accepted);
assertConflicts(testObject.conflicts, []);
});
@@ -994,9 +994,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.merge(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assertConflicts(testObject.conflicts, [preview!.resourcePreviews[0].localResource]);
});
@@ -1010,9 +1010,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
preview = await testObject.merge(preview!.resourcePreviews[0].remoteResource);
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Conflict);
assertConflicts(testObject.conflicts, [preview!.resourcePreviews[0].localResource]);
});
@@ -1026,9 +1026,9 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].remoteResource);
preview = await testObject.discard(preview!.resourcePreviews[0].previewResource);
assert.deepEqual(testObject.status, SyncStatus.Syncing);
assert.deepStrictEqual(testObject.status, SyncStatus.Syncing);
assertPreviews(preview!.resourcePreviews, [testObject.localResource]);
assert.equal(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assert.strictEqual(preview!.resourcePreviews[0].mergeState, MergeState.Preview);
assertConflicts(testObject.conflicts, []);
});
@@ -1045,11 +1045,11 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal(!(await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
test('conflicts: preivew -> accept -> discard -> accept -> apply', async () => {
@@ -1066,19 +1066,19 @@ suite('TestSynchronizer - Manual Sync', () => {
preview = await testObject.accept(preview!.resourcePreviews[0].localResource);
preview = await testObject.apply(false);
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.equal(preview, null);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.strictEqual(preview, null);
assertConflicts(testObject.conflicts, []);
assert.equal((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.equal(!(await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
assert.strictEqual((await testObject.getRemoteUserData(null)).syncData?.content, expectedContent);
assert.strictEqual((await client.instantiationService.get(IFileService).readFile(testObject.localResource)).value.toString(), expectedContent);
});
});
function assertConflicts(actual: IBaseResourcePreview[], expected: URI[]) {
assert.deepEqual(actual.map(({ localResource }) => localResource.toString()), expected.map(uri => uri.toString()));
assert.deepStrictEqual(actual.map(({ localResource }) => localResource.toString()), expected.map(uri => uri.toString()));
}
function assertPreviews(actual: IBaseResourcePreview[], expected: URI[]) {
assert.deepEqual(actual.map(({ localResource }) => localResource.toString()), expected.map(uri => uri.toString()));
assert.deepStrictEqual(actual.map(({ localResource }) => localResource.toString()), expected.map(uri => uri.toString()));
}

40
src/vs/platform/userDataSync/test/common/userDataAutoSyncService.test.ts
View File

@@ -16,8 +16,8 @@ import { joinPath } from 'vs/base/common/resources';
import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
class TestUserDataAutoSyncService extends UserDataAutoSyncService {
protected startAutoSync(): boolean { return false; }
protected getSyncTriggerDelayTime(): number { return 50; }
protected override startAutoSync(): boolean { return false; }
protected override getSyncTriggerDelayTime(): number { return 50; }
sync(): Promise<void> {
return this.triggerSync(['sync'], false, false);
@@ -49,7 +49,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
// Make sure only one manifest request is made
assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
assert.deepStrictEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
});
test('test auto sync with sync resource change triggers sync for every change', async () => {
@@ -72,7 +72,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
// Filter out machine requests
const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
assert.deepEqual(actual, [
assert.deepStrictEqual(actual, [
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }
]);
@@ -97,7 +97,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
// Make sure only one manifest request is made
assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
assert.deepStrictEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
});
test('test auto sync with non sync resource change does not trigger continuous syncs', async () => {
@@ -121,7 +121,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const actual = target.requests.filter(request => !request.url.startsWith(`${target.url}/v1/resource/machines`));
// Make sure only one manifest request is made
assert.deepEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
assert.deepStrictEqual(actual, [{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }]);
});
test('test first auto sync requests', async () => {
@@ -133,7 +133,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
await testObject.sync();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Machines
@@ -173,7 +173,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
await testObject.sync();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} }
]);
@@ -200,7 +200,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
await fileService.writeFile(environmentService.argvResource, VSBuffer.fromString(JSON.stringify({ 'locale': 'de' })));
await testObject.sync();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -264,8 +264,8 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const e = await errorPromise;
assert.ok(e instanceof UserDataAutoSyncError);
assert.deepEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.TurnedOff);
assert.deepEqual(target.requests, [
assert.deepStrictEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.TurnedOff);
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Machine
@@ -295,8 +295,8 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const e = await errorPromise;
assert.ok(e instanceof UserDataAutoSyncError);
assert.deepEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.TurnedOff);
assert.deepEqual(target.requests, [
assert.deepStrictEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.TurnedOff);
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Machine
@@ -320,7 +320,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
target.reset();
await testObject.sync();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Machine
@@ -356,8 +356,8 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const e = await errorPromise;
assert.ok(e instanceof UserDataAutoSyncError);
assert.deepEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.SessionExpired);
assert.deepEqual(target.requests, [
assert.deepStrictEqual((<UserDataAutoSyncError>e).code, UserDataSyncErrorCode.SessionExpired);
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Machine
@@ -380,7 +380,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const e = await errorPromise;
assert.ok(e instanceof UserDataSyncStoreError);
assert.deepEqual((<UserDataSyncStoreError>e).code, UserDataSyncErrorCode.TooManyRequests);
assert.deepStrictEqual((<UserDataSyncStoreError>e).code, UserDataSyncErrorCode.TooManyRequests);
});
test('test auto sync is suspended when server donot accepts requests', async () => {
@@ -398,7 +398,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
target.reset();
await testObject.sync();
assert.deepEqual(target.requests, []);
assert.deepStrictEqual(target.requests, []);
});
test('test cache control header with no cache is sent when triggered with disable cache option', async () => {
@@ -410,7 +410,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
await testObject.triggerSync(['some reason'], true, true);
assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], 'no-cache');
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['Cache-Control'], 'no-cache');
});
test('test cache control header is not sent when triggered without disable cache option', async () => {
@@ -422,7 +422,7 @@ suite.skip('UserDataAutoSyncService', () => { // {{SQL CARBON EDIT}} Service is
const testObject: TestUserDataAutoSyncService = disposableStore.add(testClient.instantiationService.createInstance(TestUserDataAutoSyncService));
await testObject.triggerSync(['some reason'], true, false);
assert.equal(target.requestsWithAllHeaders[0].headers!['Cache-Control'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['Cache-Control'], undefined);
});
});

36
src/vs/platform/userDataSync/test/common/userDataSyncService.test.ts
View File

@@ -28,7 +28,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
// Sync for first time
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -59,7 +59,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
// Sync for first time
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -93,7 +93,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
{ type: 'GET', url: `${target.url}/v1/resource/settings/latest`, headers: {} },
{ type: 'GET', url: `${target.url}/v1/resource/keybindings/latest`, headers: {} },
@@ -127,7 +127,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
{ type: 'GET', url: `${target.url}/v1/resource/settings/latest`, headers: {} },
{ type: 'POST', url: `${target.url}/v1/resource/settings`, headers: { 'If-Match': '1' } },
@@ -154,7 +154,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
]);
@@ -181,7 +181,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
// Sync from the client
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -222,7 +222,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -250,7 +250,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await testObject.reset();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'DELETE', url: `${target.url}/v1/resource`, headers: {} },
]);
@@ -273,7 +273,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
target.reset();
await (await testObject.createSyncTask()).run();
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Settings
@@ -308,7 +308,7 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
await (await testObject.createSyncTask()).run();
disposable.dispose();
assert.deepEqual(actualStatuses, [SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle]);
assert.deepStrictEqual(actualStatuses, [SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle, SyncStatus.Syncing, SyncStatus.Idle]);
});
test('test sync conflicts status', async () => {
@@ -333,8 +333,8 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
// sync from the client
await (await testObject.createSyncTask()).run();
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepEqual(testObject.conflicts.map(([syncResource]) => syncResource), [SyncResource.Settings]);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(testObject.conflicts.map(([syncResource]) => syncResource), [SyncResource.Settings]);
});
test('test sync will sync other non conflicted areas', async () => {
@@ -368,10 +368,10 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
await (await testObject.createSyncTask()).run();
disposable.dispose();
assert.deepEqual(actualStatuses, []);
assert.deepEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepStrictEqual(actualStatuses, []);
assert.deepStrictEqual(testObject.status, SyncStatus.HasConflicts);
assert.deepEqual(target.requests, [
assert.deepStrictEqual(target.requests, [
// Manifest
{ type: 'GET', url: `${target.url}/v1/manifest`, headers: {} },
// Keybindings
@@ -400,11 +400,11 @@ suite.skip('UserDataSyncService', () => { // {{SQL CARBON EDIT}} skip failing te
const syncTask = (await testObject.createSyncTask());
syncTask.run();
syncTask.run().then(null, () => null /* ignore error */);
await syncTask.stop();
assert.deepEqual(testObject.status, SyncStatus.Idle);
assert.deepEqual(testObject.conflicts, []);
assert.deepStrictEqual(testObject.status, SyncStatus.Idle);
assert.deepStrictEqual(testObject.conflicts, []);
});
test('test sync send execution id header', async () => {

118
src/vs/platform/userDataSync/test/common/userDataSyncStoreService.test.ts
View File

@@ -7,7 +7,8 @@ import * as assert from 'assert';
import { IUserDataSyncStoreService, SyncResource, UserDataSyncErrorCode, UserDataSyncStoreError, IUserDataSyncStoreManagementService, IUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
import { UserDataSyncClient, UserDataSyncTestServer } from 'vs/platform/userDataSync/test/common/userDataSyncClient';
import { DisposableStore } from 'vs/base/common/lifecycle';
import { IProductService, ConfigurationSyncStore } from 'vs/platform/product/common/productService';
import { IProductService } from 'vs/platform/product/common/productService';
import { ConfigurationSyncStore } from 'vs/base/common/product';
import { isWeb } from 'vs/base/common/platform';
import { RequestsSession, UserDataSyncStoreService, UserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
import { CancellationToken } from 'vs/base/common/cancellation';
@@ -51,6 +52,7 @@ suite('UserDataSyncStoreManagementService', () => {
const expected: IUserDataSyncStore = {
url: URI.parse('http://configureHost:3000'),
type: 'stable',
defaultUrl: URI.parse('http://configureHost:3000'),
stableUrl: URI.parse('http://configureHost:3000'),
insidersUrl: URI.parse('http://configureHost:3000'),
@@ -60,9 +62,9 @@ suite('UserDataSyncStoreManagementService', () => {
const testObject: IUserDataSyncStoreManagementService = disposableStore.add(client.instantiationService.createInstance(UserDataSyncStoreManagementService));
assert.equal(testObject.userDataSyncStore?.url.toString(), expected.url.toString());
assert.equal(testObject.userDataSyncStore?.defaultUrl.toString(), expected.defaultUrl.toString());
assert.deepEqual(testObject.userDataSyncStore?.authenticationProviders, expected.authenticationProviders);
assert.strictEqual(testObject.userDataSyncStore?.url.toString(), expected.url.toString());
assert.strictEqual(testObject.userDataSyncStore?.defaultUrl.toString(), expected.defaultUrl.toString());
assert.deepStrictEqual(testObject.userDataSyncStore?.authenticationProviders, expected.authenticationProviders);
});
});
@@ -83,12 +85,12 @@ suite('UserDataSyncStoreService', () => {
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Client-Name'], `${productService.applicationName}${isWeb ? '-web' : ''}`);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Client-Version'], productService.version);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Client-Name'], `${productService.applicationName}${isWeb ? '-web' : ''}`);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Client-Version'], productService.version);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test read manifest for the second time when session is not yet created', async () => {
@@ -104,9 +106,9 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test session id header is not set in the first manifest request after session is created', async () => {
@@ -123,9 +125,9 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test session id header is set from the second manifest request after session is created', async () => {
@@ -143,9 +145,9 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test headers are send for write request', async () => {
@@ -164,9 +166,9 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.write(SyncResource.Settings, 'some content', null);
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test headers are send for read request', async () => {
@@ -185,9 +187,9 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.read(SyncResource.Settings, null);
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test headers are reset after session is cleared ', async () => {
@@ -207,10 +209,10 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test old headers are sent after session is changed on server ', async () => {
@@ -238,11 +240,11 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
});
test('test old headers are reset from second request after session is changed on server ', async () => {
@@ -271,11 +273,11 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
});
test('test old headers are sent after session is cleared from another server ', async () => {
@@ -302,11 +304,11 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
});
test('test headers are reset after session is cleared from another server ', async () => {
@@ -333,10 +335,10 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.equal(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.strictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test headers are reset after session is cleared from another server - started syncing again', async () => {
@@ -366,11 +368,11 @@ suite('UserDataSyncStoreService', () => {
target.reset();
await testObject.manifest();
assert.equal(target.requestsWithAllHeaders.length, 1);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
assert.notEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
assert.strictEqual(target.requestsWithAllHeaders.length, 1);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], undefined);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-Machine-Session-Id'], machineSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], userSessionId);
assert.notStrictEqual(target.requestsWithAllHeaders[0].headers!['X-User-Session-Id'], undefined);
});
test('test rate limit on server with retry after', async () => {
@@ -387,7 +389,7 @@ suite('UserDataSyncStoreService', () => {
assert.fail('should fail');
} catch (e) {
assert.ok(e instanceof UserDataSyncStoreError);
assert.deepEqual((<UserDataSyncStoreError>e).code, UserDataSyncErrorCode.TooManyRequestsAndRetryAfter);
assert.deepStrictEqual((<UserDataSyncStoreError>e).code, UserDataSyncErrorCode.TooManyRequestsAndRetryAfter);
await promise;
assert.ok(!!testObject.donotMakeRequestsUntil);
}
@@ -420,7 +422,7 @@ suite('UserDataSyncStoreService', () => {
} catch (e) { }
const target = disposableStore.add(client.instantiationService.createInstance(UserDataSyncStoreService));
assert.equal(target.donotMakeRequestsUntil?.getTime(), testObject.donotMakeRequestsUntil?.getTime());
assert.strictEqual(target.donotMakeRequestsUntil?.getTime(), testObject.donotMakeRequestsUntil?.getTime());
});
test('test donotMakeRequestsUntil is checked and reset after retreived', async () => {
@@ -449,7 +451,7 @@ suite('UserDataSyncStoreService', () => {
const expected = await testObject.read(SyncResource.Settings, null);
const actual = await testObject.read(SyncResource.Settings, expected);
assert.equal(actual, expected);
assert.strictEqual(actual, expected);
});
});
@@ -470,7 +472,7 @@ suite('UserDataSyncRequestsSession', () => {
await testObject.request('url', {}, CancellationToken.None);
} catch (error) {
assert.ok(error instanceof UserDataSyncStoreError);
assert.equal((<UserDataSyncStoreError>error).code, UserDataSyncErrorCode.LocalTooManyRequests);
assert.strictEqual((<UserDataSyncStoreError>error).code, UserDataSyncErrorCode.LocalTooManyRequests);
return;
}
assert.fail('Should fail with limit exceeded');
@@ -493,7 +495,7 @@ suite('UserDataSyncRequestsSession', () => {
await testObject.request('url', {}, CancellationToken.None);
} catch (error) {
assert.ok(error instanceof UserDataSyncStoreError);
assert.equal((<UserDataSyncStoreError>error).code, UserDataSyncErrorCode.LocalTooManyRequests);
assert.strictEqual((<UserDataSyncStoreError>error).code, UserDataSyncErrorCode.LocalTooManyRequests);
return;
}
assert.fail('Should fail with limit exceeded');