test('copyFile - overwrite folder with file', async () => {
let createEvent: FileOperationEvent;
let copyEvent: FileOperationEvent;
let deleteEvent: FileOperationEvent;
disposables.push(service.onAfterOperation(e => {
if (e.operation === FileOperation.CREATE) {
createEvent = e;
} else if (e.operation === FileOperation.DELETE) {
deleteEvent = e;
} else if (e.operation === FileOperation.COPY) {
copyEvent = e;
}
}));
const parent = await service.resolveFile(URI.file(testDir));
const folderResource = URI.file(join(parent.resource.fsPath, 'conway.js'));
const f = await service.createFolder(folderResource);
const source = URI.file(join(testDir, 'deep', 'conway.js'));
const copied = await service.copyFile(source, f.resource, true);
assert.equal(existsSync(copied.resource.fsPath), true);
assert.ok(statSync(copied.resource.fsPath).isFile);
assert.ok(createEvent!);
assert.ok(deleteEvent!);
assert.ok(copyEvent!);
assert.equal(copyEvent!.resource.fsPath, source.fsPath);
assert.equal(copyEvent!.target!.resource.fsPath, copied.resource.fsPath);
assert.equal(deleteEvent!.resource.fsPath, folderResource.fsPath);
});
test('existsFile', async () => {
let exists = await service.existsFile(URI.file(testDir));
assert.equal(exists, true);
exists = await service.existsFile(URI.file(testDir + 'something'));
assert.equal(exists, false);
});
test('copyFile - same file should throw', async () => {
const source = await service.resolveFile(URI.file(join(testDir, 'index.html')));
const targetParent = URI.file(dirname(source.resource.fsPath));
const target = targetParent.with({ path: posix.join(targetParent.path, posix.basename(source.resource.path)) });
try {
await service.copyFile(source.resource, target, true);
} catch (error) {
assert.ok(error);
}
});
test('deleteFolder (non recursive)', async () => {
const resource = URI.file(join(testDir, 'deep'));
const source = await service.resolveFile(resource);
try {
await service.del(source.resource);
return Promise.reject(new Error('Unexpected'));
}
catch (error) {
return Promise.resolve(true);
}
});
test('moveFile - FILE_MOVE_CONFLICT', async () => {
let event: FileOperationEvent;
disposables.push(service.onAfterOperation(e => event = e));
const source = await service.resolveFile(URI.file(join(testDir, 'index.html')));
try {
await service.moveFile(source.resource, URI.file(join(testDir, 'binary.txt')));
} catch (e) {
assert.equal(e.fileOperationResult, FileOperationResult.FILE_MOVE_CONFLICT);
assert.ok(!event!);
}
});
test('moveFile - source parent of target', async () => {
let event: FileOperationEvent;
disposables.push(service.onAfterOperation(e => event = e));
await service.resolveFile(URI.file(join(testDir, 'index.html')));
try {
await service.moveFile(URI.file(testDir), URI.file(join(testDir, 'binary.txt')));
} catch (e) {
assert.ok(e);
assert.ok(!event!);
}
});
test('copyFile - MIX CASE', async () => {
const source = await service.resolveFile(URI.file(join(testDir, 'index.html')));
const renamed = await service.moveFile(source.resource, URI.file(join(dirname(source.resource.fsPath), 'CONWAY.js')));
assert.equal(existsSync(renamed.resource.fsPath), true);
assert.ok(readdirSync(testDir).some(f => f === 'CONWAY.js'));
const source_1 = await service.resolveFile(URI.file(join(testDir, 'deep', 'conway.js')));
const targetParent = URI.file(testDir);
const target = targetParent.with({ path: posix.join(targetParent.path, posix.basename(source_1.resource.path)) });
const res = await service.copyFile(source_1.resource, target, true);
assert.equal(existsSync(res.resource.fsPath), true);
assert.ok(readdirSync(testDir).some(f => f === 'conway.js'));
});
test('deleteFolder (recursive)', async () => {
let event: FileOperationEvent;
disposables.push(service.onAfterOperation(e => event = e));
const resource = URI.file(join(testDir, 'deep'));
const source = await service.resolveFile(resource);
await service.del(source.resource, { recursive: true });
assert.equal(existsSync(source.resource.fsPath), false);
assert.ok(event!);
assert.equal(event!.resource.fsPath, resource.fsPath);
assert.equal(event!.operation, FileOperation.DELETE);
});
test('moveFile - directory', async () => {
let event: FileOperationEvent;
disposables.push(service.onAfterOperation(e => event = e));
const source = URI.file(join(testDir, 'deep'));
const renamed = await service.moveFile(source, URI.file(join(dirname(source.fsPath), 'deeper')));
assert.equal(existsSync(renamed.resource.fsPath), true);
assert.equal(existsSync(source.fsPath), false);
assert.ok(event!);
assert.equal(event!.resource.fsPath, source.fsPath);
assert.equal(event!.operation, FileOperation.MOVE);
assert.equal(event!.target!.resource.fsPath, renamed.resource.fsPath);
});
test('provider registration', async () => {
const service = new FileService2(new NullLogService());
const resource = URI.parse('test://foo/bar');
assert.equal(service.canHandleResource(resource), false);
const registrations: IFileSystemProviderRegistrationEvent[] = [];
service.onDidChangeFileSystemProviderRegistrations(e => {
registrations.push(e);
});
let registrationDisposable: IDisposable | undefined = undefined;
let callCount = 0;
service.onWillActivateFileSystemProvider(e => {
callCount++;
if (e.scheme === 'test' && callCount === 1) {
e.join(new Promise(resolve => {
registrationDisposable = service.registerProvider('test', new NullFileSystemProvider());
resolve();
}));
}
});
await service.activateProvider('test');
assert.equal(service.canHandleResource(resource), true);
assert.equal(registrations.length, 1);
assert.equal(registrations[0].scheme, 'test');
assert.equal(registrations[0].added, true);
assert.ok(registrationDisposable);
await service.activateProvider('test');
assert.equal(callCount, 2); // activation is called again
assert.equal(await service.hasCapability(resource, FileSystemProviderCapabilities.Readonly), true);
assert.equal(await service.hasCapability(resource, FileSystemProviderCapabilities.FileOpenReadWriteClose), false);
registrationDisposable!.dispose();
assert.equal(service.canHandleResource(resource), false);
assert.equal(registrations.length, 2);
assert.equal(registrations[1].scheme, 'test');
assert.equal(registrations[1].added, false);
});
