'use strict';

const mockFs = require('mock-fs');

import * as ts from 'typescript';

import * as path from 'path';

import * as dependentFilesUtils from '@angular/cli/utilities/get-dependent-files';

import { expect } from 'chai';

import { ModuleResolver } from '@angular/cli/utilities/module-resolver';

describe('ModuleResolver', () => {

let rootPath = 'src/app';

beforeEach(() => {

let mockDrive = {

'src/app': {

'foo': {

'foo.component.ts': `import * from "../bar/baz/baz.component";`,

},

'bar': {

'baz': {

'baz.component.ts': `import * from "../bar.component"

import * from '../../foo-baz/qux/quux/foobar/foobar.component'

`,

'baz.component.spec.ts': 'import * from "./baz.component";'

},

'bar.component.ts': `import * from './baz/baz.component'

import * from '../foo/foo.component'`,

},

'foo-baz': {

'qux': {

'quux': {

'foobar': {

'foobar.component.ts': `import * from "../../../../foo/foo.component"

import * from '../fooqux.component'

`,

},

'fooqux': {

'fooqux.component.ts': 'import * from "../foobar/foobar.component"'

}

}

},

'no-module.component.ts': '',

'foo-baz.component.ts': 'import * from \n"../foo/foo.component"\n'

},

'empty-dir': {}

}

};

mockFs(mockDrive);

});

afterEach(() => {

mockFs.restore();

});

describe('Rewrite imports', () => {

// Normalize paths for platform specific delimeter.

let barFile = path.join(rootPath, 'bar/bar.component.ts');

let fooFile = path.join(rootPath, 'foo/foo.component.ts');

let bazFile = path.join(rootPath, 'bar/baz/baz.component.ts');

let fooBazFile = path.join(rootPath, 'foo-baz/foo-baz.component.ts');

let fooBarFile = path.join(rootPath, 'foo-baz/qux/quux/foobar/foobar.component.ts');

let fooQuxFile = path.join(rootPath, 'foo-baz/qux/quux/fooqux/fooqux.component.ts');

it('when there is no index.ts in oldPath', () => {

let oldFilePath = path.join(rootPath, 'bar/baz/baz.component.ts');

let newFilePath = path.join(rootPath, 'foo');

let resolver = new ModuleResolver(oldFilePath, newFilePath, rootPath);

return resolver.resolveDependentFiles()

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(barFile))

.then((tsFileBar: ts.SourceFile) => {

let contentsBar = dependentFilesUtils.getImportClauses(tsFileBar);

let bazExpectedContent = path.normalize('../foo/baz.component');

expect(contentsBar[0].specifierText).to.equal(bazExpectedContent);

})

.then(() => dependentFilesUtils.createTsSourceFile(fooFile))

.then((tsFileFoo: ts.SourceFile) => {

let contentsFoo = dependentFilesUtils.getImportClauses(tsFileFoo);

let bazExpectedContent = './baz.component'.replace('/', path.sep);

expect(contentsFoo[0].specifierText).to.equal(bazExpectedContent);

})

.then(() => resolver.resolveOwnImports())

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(bazFile))

.then((tsFileBaz: ts.SourceFile) => {

let contentsBaz = dependentFilesUtils.getImportClauses(tsFileBaz);

let barExpectedContent = path.normalize('../bar/bar.component');

let fooBarExpectedContent = path.normalize('../foo-baz/qux/quux/foobar/foobar.component');

expect(contentsBaz[0].specifierText).to.equal(barExpectedContent);

expect(contentsBaz[1].specifierText).to.equal(fooBarExpectedContent);

});

});

it('when no files are importing the given file', () => {

let oldFilePath = path.join(rootPath, 'foo-baz/foo-baz.component.ts');

let newFilePath = path.join(rootPath, 'bar');

let resolver = new ModuleResolver(oldFilePath, newFilePath, rootPath);

return resolver.resolveDependentFiles()

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => resolver.resolveOwnImports())

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(fooBazFile))

.then((tsFile: ts.SourceFile) => {

let contents = dependentFilesUtils.getImportClauses(tsFile);

let fooExpectedContent = path.normalize('../foo/foo.component');

expect(contents[0].specifierText).to.equal(fooExpectedContent);

});

});

it('when oldPath and newPath both do not have index.ts', () => {

let oldFilePath = path.join(rootPath, 'bar/baz/baz.component.ts');

let newFilePath = path.join(rootPath, 'foo-baz');

let resolver = new ModuleResolver(oldFilePath, newFilePath, rootPath);

return resolver.resolveDependentFiles()

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(barFile))

.then((tsFileBar: ts.SourceFile) => {

let contentsBar = dependentFilesUtils.getImportClauses(tsFileBar);

let bazExpectedContent = path.normalize('../foo-baz/baz.component');

expect(contentsBar[0].specifierText).to.equal(bazExpectedContent);

})

.then(() => dependentFilesUtils.createTsSourceFile(fooFile))

.then((tsFileFoo: ts.SourceFile) => {

let contentsFoo = dependentFilesUtils.getImportClauses(tsFileFoo);

let bazExpectedContent = path.normalize('../foo-baz/baz.component');

expect(contentsFoo[0].specifierText).to.equal(bazExpectedContent);

})

.then(() => resolver.resolveOwnImports())

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(bazFile))

.then((tsFile: ts.SourceFile) => {

let contentsBaz = dependentFilesUtils.getImportClauses(tsFile);

let barExpectedContent = path.normalize('../bar/bar.component');

let fooBarExpectedContent =

`.${path.sep}qux${path.sep}quux${path.sep}foobar${path.sep}foobar.component`;

expect(contentsBaz[0].specifierText).to.equal(barExpectedContent);

expect(contentsBaz[1].specifierText).to.equal(fooBarExpectedContent);

});

});

it('when there are multiple spaces between symbols and specifier', () => {

let oldFilePath = path.join(rootPath, 'foo-baz/qux/quux/foobar/foobar.component.ts');

let newFilePath = path.join(rootPath, 'foo');

let resolver = new ModuleResolver(oldFilePath, newFilePath, rootPath);

return resolver.resolveDependentFiles()

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(fooQuxFile))

.then((tsFileFooQux: ts.SourceFile) => {

let contentsFooQux = dependentFilesUtils.getImportClauses(tsFileFooQux);

let fooQuxExpectedContent = path.normalize('../../../../foo/foobar.component');

expect(contentsFooQux[0].specifierText).to.equal(fooQuxExpectedContent);

})

.then(() => dependentFilesUtils.createTsSourceFile(bazFile))

.then((tsFileBaz: ts.SourceFile) => {

let contentsBaz = dependentFilesUtils.getImportClauses(tsFileBaz);

let bazExpectedContent = path.normalize('../../foo/foobar.component');

expect(contentsBaz[1].specifierText).to.equal(bazExpectedContent);

})

.then(() => resolver.resolveOwnImports())

.then((changes) => resolver.applySortedChangePromise(changes))

.then(() => dependentFilesUtils.createTsSourceFile(fooBarFile))

.then((tsFileFooBar: ts.SourceFile) => {

let contentsFooBar = dependentFilesUtils.getImportClauses(tsFileFooBar);

let fooExpectedContent = `.${path.sep}foo.component`;

let fooQuxExpectedContent = path.normalize('../foo-baz/qux/quux/fooqux.component');

expect(contentsFooBar[0].specifierText).to.equal(fooExpectedContent);

expect(contentsFooBar[1].specifierText).to.equal(fooQuxExpectedContent);

});

});

});

});