fix: Add tests, handle windows paths in project-manager

tomv564 · tomv564 · commit 96d6c476a9ba · 2017-10-04T23:30:30.000+02:00
diff --git a/src/project-manager.ts b/src/project-manager.ts
@@ -589,7 +589,7 @@ export class ProjectManager implements Disposable {
 
         // Create catch-all fallback configs in case there are no tsconfig.json files
         // They are removed once at least one tsconfig.json is found
-        const trimmedRootPath = this.rootPath.replace(/\/+$/, '')
+        const trimmedRootPath = this.rootPath.replace(/[\\\/]+$/, '')
         const fallbackConfigs: {js?: ProjectConfiguration, ts?: ProjectConfiguration} = {}
         for (const configType of ['js', 'ts'] as ConfigType[]) {
             const configs = this.configs[configType]
@@ -622,13 +622,8 @@ export class ProjectManager implements Disposable {
                 .filter(([uri, content]) => !!content && /\/[tj]sconfig\.json/.test(uri) && !uri.includes('/node_modules/'))
                 .subscribe(([uri, content]) => {
                     const filePath = uri2path(uri)
-                    let dir = toUnixPath(filePath)
-                    const pos = dir.lastIndexOf('/')
-                    if (pos <= 0) {
-                        dir = ''
-                    } else {
-                        dir = dir.substring(0, pos)
-                    }
+                    const pos = filePath.includes('\\') ? filePath.lastIndexOf('\\') : filePath.lastIndexOf('/')
+                    const dir = pos <= 0 ? '' : filePath.substring(0, pos)
                     const configType = this.getConfigurationType(filePath)
                     const configs = this.configs[configType]
                     configs.set(dir, new ProjectConfiguration(
@@ -930,19 +925,19 @@ export class ProjectManager implements Disposable {
      * @return closest configuration for a given file path or undefined if there is no such configuration
      */
     public getConfigurationIfExists(filePath: string, configType = this.getConfigurationType(filePath)): ProjectConfiguration | undefined {
-        let dir = toUnixPath(filePath)
+        let dir = filePath
         let config: ProjectConfiguration | undefined
         const configs = this.configs[configType]
         if (!configs) {
             return undefined
         }
-        const rootPath = this.rootPath.replace(/\/+$/, '')
+        const rootPath = this.rootPath.replace(/[\\\/]+$/, '')
         while (dir && dir !== rootPath) {
             config = configs.get(dir)
             if (config) {
                 return config
             }
-            const pos = dir.lastIndexOf('/')
+            const pos = dir.includes('\\') ? dir.lastIndexOf('\\') : dir.lastIndexOf('/')
             if (pos <= 0) {
                 dir = ''
             } else {
@@ -1030,13 +1025,14 @@ export class ProjectManager implements Disposable {
      * @return configuration type to use for a given file
      */
     private getConfigurationType(filePath: string): ConfigType {
-        const name = path.posix.basename(filePath)
+        const unixPath = toUnixPath(filePath)
+        const name = path.posix.basename(unixPath)
         if (name === 'tsconfig.json') {
             return 'ts'
         } else if (name === 'jsconfig.json') {
             return 'js'
         }
-        const extension = path.posix.extname(filePath)
+        const extension = path.posix.extname(unixPath)
         if (extension === '.js' || extension === '.jsx') {
             return 'js'
         }
diff --git a/src/test/project-manager.test.ts b/src/test/project-manager.test.ts
@@ -3,134 +3,157 @@ import chaiAsPromised = require('chai-as-promised')
 import { FileSystemUpdater } from '../fs'
 import { InMemoryFileSystem } from '../memfs'
 import { ProjectManager } from '../project-manager'
+import { uri2path } from '../util'
 import { MapFileSystem } from './fs-helpers'
 chai.use(chaiAsPromised)
 const assert = chai.assert
 
 describe('ProjectManager', () => {
+    for (const rootUri of ['file:///', 'file:///c:/foo/bar/', 'file:///foo/bar/']) {
+        testWithRootUri(rootUri)
+    }
+})
 
-    let projectManager: ProjectManager
-    let memfs: InMemoryFileSystem
+function testWithRootUri(rootUri: string): void {
+    describe(`with rootUri ${rootUri}`, () => {
 
-    it('should add a ProjectConfiguration when a tsconfig.json is added to the InMemoryFileSystem', () => {
-        memfs = new InMemoryFileSystem('/')
-        const localfs = new MapFileSystem(new Map([
-            ['file:///foo/tsconfig.json', '{}']
-        ]))
-        const updater = new FileSystemUpdater(localfs, memfs)
-        projectManager = new ProjectManager('/', memfs, updater, true)
-        memfs.add('file:///foo/tsconfig.json', '{}')
-        const configs = Array.from(projectManager.configurations())
-        assert.isDefined(configs.find(config => config.configFilePath === '/foo/tsconfig.json'))
-    })
+        let projectManager: ProjectManager
+        let memfs: InMemoryFileSystem
 
-    describe('ensureBasicFiles', () => {
-        beforeEach(async () => {
-            memfs = new InMemoryFileSystem('/')
+        it('should add a ProjectConfiguration when a tsconfig.json is added to the InMemoryFileSystem', () => {
+            const rootPath = uri2path(rootUri)
+            memfs = new InMemoryFileSystem(rootPath)
+            const configFileUri = rootUri + 'foo/tsconfig.json'
             const localfs = new MapFileSystem(new Map([
-                ['file:///project/package.json', '{"name": "package-name-1"}'],
-                ['file:///project/tsconfig.json', '{ "compilerOptions": { "typeRoots": ["../types"]} }'],
-                ['file:///project/file.ts', 'console.log(GLOBALCONSTANT);'],
-                ['file:///types/types.d.ts', 'declare var GLOBALCONSTANT=1;']
-
+                [configFileUri, '{}']
             ]))
             const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
-        })
-        it('loads files from typeRoots', async () => {
-            await projectManager.ensureReferencedFiles('file:///project/file.ts').toPromise()
-            memfs.getContent('file:///project/file.ts')
-            memfs.getContent('file:///types/types.d.ts')
-        })
-    })
+            projectManager = new ProjectManager(rootPath, memfs, updater, true)
+            memfs.add(configFileUri, '{}')
+            const configs = Array.from(projectManager.configurations())
+            const expectedConfigFilePath = uri2path(configFileUri)
 
-    describe('getPackageName()', () => {
-        beforeEach(async () => {
-            memfs = new InMemoryFileSystem('/')
-            const localfs = new MapFileSystem(new Map([
-                ['file:///package.json', '{"name": "package-name-1"}'],
-                ['file:///subdirectory-with-tsconfig/package.json', '{"name": "package-name-2"}'],
-                ['file:///subdirectory-with-tsconfig/src/tsconfig.json', '{}'],
-                ['file:///subdirectory-with-tsconfig/src/dummy.ts', '']
-            ]))
-            const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
-            await projectManager.ensureAllFiles().toPromise()
-        })
-    })
-    describe('ensureReferencedFiles()', () => {
-        beforeEach(() => {
-            memfs = new InMemoryFileSystem('/')
-            const localfs = new MapFileSystem(new Map([
-                ['file:///package.json', '{"name": "package-name-1"}'],
-                ['file:///node_modules/somelib/index.js', '/// <reference path="./pathref.d.ts"/>\n/// <reference types="node"/>'],
-                ['file:///node_modules/somelib/pathref.d.ts', ''],
-                ['file:///node_modules/%40types/node/index.d.ts', ''],
-                ['file:///src/dummy.ts', 'import * as somelib from "somelib";']
-            ]))
-            const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
+            assert.isDefined(configs.find(config => config.configFilePath === expectedConfigFilePath))
         })
-        it('should ensure content for imports and references is fetched', async () => {
-            await projectManager.ensureReferencedFiles('file:///src/dummy.ts').toPromise()
-            memfs.getContent('file:///node_modules/somelib/index.js')
-            memfs.getContent('file:///node_modules/somelib/pathref.d.ts')
-            memfs.getContent('file:///node_modules/%40types/node/index.d.ts')
-        })
-    })
-    describe('getConfiguration()', () => {
-        beforeEach(async () => {
-            memfs = new InMemoryFileSystem('/')
-            const localfs = new MapFileSystem(new Map([
-                ['file:///tsconfig.json', '{}'],
-                ['file:///src/jsconfig.json', '{}']
-            ]))
-            const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
-            await projectManager.ensureAllFiles().toPromise()
+
+        describe('ensureBasicFiles', () => {
+            beforeEach(async () => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'project/package.json', '{"name": "package-name-1"}'],
+                    [rootUri + 'project/tsconfig.json', '{ "compilerOptions": { "typeRoots": ["../types"]} }'],
+                    [rootUri + 'project/file.ts', 'console.log(GLOBALCONSTANT);'],
+                    [rootUri + 'types/types.d.ts', 'declare var GLOBALCONSTANT=1;']
+
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+            })
+            it('loads files from typeRoots', async () => {
+                await projectManager.ensureReferencedFiles(rootUri + 'project/file.ts').toPromise()
+                memfs.getContent(rootUri + 'project/file.ts')
+                memfs.getContent(rootUri + 'types/types.d.ts')
+            })
         })
-        it('should resolve best configuration based on file name', () => {
-            const jsConfig = projectManager.getConfiguration('/src/foo.js')
-            const tsConfig = projectManager.getConfiguration('/src/foo.ts')
-            assert.equal('/tsconfig.json', tsConfig.configFilePath)
-            assert.equal('/src/jsconfig.json', jsConfig.configFilePath)
+
+        describe('getPackageName()', () => {
+            beforeEach(async () => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'package.json', '{"name": "package-name-1"}'],
+                    [rootUri + 'subdirectory-with-tsconfig/package.json', '{"name": "package-name-2"}'],
+                    [rootUri + 'subdirectory-with-tsconfig/src/tsconfig.json', '{}'],
+                    [rootUri + 'subdirectory-with-tsconfig/src/dummy.ts', '']
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+                await projectManager.ensureAllFiles().toPromise()
+            })
         })
-    })
-    describe('getParentConfiguration()', () => {
-        beforeEach(async () => {
-            memfs = new InMemoryFileSystem('/')
-            const localfs = new MapFileSystem(new Map([
-                ['file:///tsconfig.json', '{}'],
-                ['file:///src/jsconfig.json', '{}']
-            ]))
-            const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
-            await projectManager.ensureAllFiles().toPromise()
+
+        describe('ensureReferencedFiles()', () => {
+            beforeEach(() => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'package.json', '{"name": "package-name-1"}'],
+                    [rootUri + 'node_modules/somelib/index.js', '/// <reference path="./pathref.d.ts"/>\n/// <reference types="node"/>'],
+                    [rootUri + 'node_modules/somelib/pathref.d.ts', ''],
+                    [rootUri + 'node_modules/%40types/node/index.d.ts', ''],
+                    [rootUri + 'src/dummy.ts', 'import * as somelib from "somelib";']
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+            })
+            it('should ensure content for imports and references is fetched', async () => {
+                await projectManager.ensureReferencedFiles(rootUri + 'src/dummy.ts').toPromise()
+                memfs.getContent(rootUri + 'node_modules/somelib/index.js')
+                memfs.getContent(rootUri + 'node_modules/somelib/pathref.d.ts')
+                memfs.getContent(rootUri + 'node_modules/%40types/node/index.d.ts')
+            })
         })
-        it('should resolve best configuration based on file name', () => {
-            const config = projectManager.getParentConfiguration('file:///src/foo.ts')
-            assert.isDefined(config)
-            assert.equal('/tsconfig.json', config!.configFilePath)
+        describe('getConfiguration()', () => {
+            beforeEach(async () => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'tsconfig.json', '{}'],
+                    [rootUri + 'src/jsconfig.json', '{}']
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+                await projectManager.ensureAllFiles().toPromise()
+            })
+            it('should resolve best configuration based on file name', () => {
+                const jsConfig = projectManager.getConfiguration(uri2path(rootUri + 'src/foo.js'))
+                const tsConfig = projectManager.getConfiguration(uri2path(rootUri + 'src/foo.ts'))
+                assert.equal(uri2path(rootUri + 'tsconfig.json'), tsConfig.configFilePath)
+                assert.equal(uri2path(rootUri + 'src/jsconfig.json'), jsConfig.configFilePath)
+                assert.equal(Array.from(projectManager.configurations()).length, 2)
+            })
         })
-    })
-    describe('getChildConfigurations()', () => {
-        beforeEach(async () => {
-            memfs = new InMemoryFileSystem('/')
-            const localfs = new MapFileSystem(new Map([
-                ['file:///tsconfig.json', '{}'],
-                ['file:///foo/bar/tsconfig.json', '{}'],
-                ['file:///foo/baz/tsconfig.json', '{}']
-            ]))
-            const updater = new FileSystemUpdater(localfs, memfs)
-            projectManager = new ProjectManager('/', memfs, updater, true)
-            await projectManager.ensureAllFiles().toPromise()
+        describe('getParentConfiguration()', () => {
+            beforeEach(async () => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'tsconfig.json', '{}'],
+                    [rootUri + 'src/jsconfig.json', '{}']
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+                await projectManager.ensureAllFiles().toPromise()
+            })
+            it('should resolve best configuration based on file name', () => {
+                const config = projectManager.getParentConfiguration(rootUri + 'src/foo.ts')
+                assert.isDefined(config)
+                assert.equal(uri2path(rootUri + 'tsconfig.json'), config!.configFilePath)
+                assert.equal(Array.from(projectManager.configurations()).length, 2)
+            })
         })
-        it('should resolve best configuration based on file name', () => {
-            const configs = Array.from(projectManager.getChildConfigurations('file:///foo')).map(config => config.configFilePath)
-            assert.deepEqual(configs, [
-                '/foo/bar/tsconfig.json',
-                '/foo/baz/tsconfig.json'
-            ])
+        describe('getChildConfigurations()', () => {
+            beforeEach(async () => {
+                const rootPath = uri2path(rootUri)
+                memfs = new InMemoryFileSystem(rootPath)
+                const localfs = new MapFileSystem(new Map([
+                    [rootUri + 'tsconfig.json', '{}'],
+                    [rootUri + 'foo/bar/tsconfig.json', '{}'],
+                    [rootUri + 'foo/baz/tsconfig.json', '{}']
+                ]))
+                const updater = new FileSystemUpdater(localfs, memfs)
+                projectManager = new ProjectManager(rootPath, memfs, updater, true)
+                await projectManager.ensureAllFiles().toPromise()
+            })
+            it('should resolve best configuration based on file name', () => {
+                const configs = Array.from(projectManager.getChildConfigurations(rootUri + 'foo')).map(config => config.configFilePath)
+                assert.deepEqual(configs, [
+                    uri2path(rootUri + 'foo/bar/tsconfig.json'),
+                    uri2path(rootUri + 'foo/baz/tsconfig.json')
+                ])
+                assert.equal(Array.from(projectManager.configurations()).length, 4)
+            })
         })
     })
-})
+}
