139 lines
4.1 KiB
TypeScript
139 lines
4.1 KiB
TypeScript
var mockfs = require('mock-fs');
|
|
|
|
import * as ts from 'typescript';
|
|
import * as fs from 'fs';
|
|
import {MockHost, expectNoDiagnostics, findClass} from './typescript.mock';
|
|
import {MetadataExtractor} from './extractor';
|
|
|
|
describe('MetadataExtractor', () => {
|
|
// Read the lib.d.ts before mocking fs.
|
|
let libTs: string = fs.readFileSync(ts.getDefaultLibFilePath({}), 'utf8');
|
|
|
|
beforeEach(() => files['lib.d.ts'] = libTs);
|
|
beforeEach(() => mockfs(files));
|
|
afterEach(() => mockfs.restore());
|
|
|
|
let host: ts.LanguageServiceHost;
|
|
let service: ts.LanguageService;
|
|
let program: ts.Program;
|
|
let typeChecker: ts.TypeChecker;
|
|
let extractor: MetadataExtractor;
|
|
|
|
beforeEach(() => {
|
|
host = new MockHost(['A.ts', 'B.ts', 'C.ts'], /*currentDirectory*/ undefined, 'lib.d.ts');
|
|
service = ts.createLanguageService(host);
|
|
program = service.getProgram();
|
|
typeChecker = program.getTypeChecker();
|
|
extractor = new MetadataExtractor(service);
|
|
});
|
|
|
|
it('should not have typescript errors in test data', () => {
|
|
expectNoDiagnostics(service.getCompilerOptionsDiagnostics());
|
|
for (const sourceFile of program.getSourceFiles()) {
|
|
expectNoDiagnostics(service.getSyntacticDiagnostics(sourceFile.fileName));
|
|
}
|
|
});
|
|
|
|
it('should be able to extract metadata when defined by literals', () => {
|
|
const sourceFile = program.getSourceFile('A.ts');
|
|
const metadata = extractor.getMetadata(sourceFile, typeChecker);
|
|
expect(metadata).toEqual({
|
|
__symbolic: 'module',
|
|
module: './A',
|
|
metadata: {
|
|
A: {
|
|
__symbolic: 'class',
|
|
decorators: [
|
|
{
|
|
__symbolic: 'call',
|
|
expression: {__symbolic: 'reference', name: 'Pipe', module: './directives'},
|
|
arguments: [{name: 'A', pure: false}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
it('should be able to extract metadata from metadata defined using vars', () => {
|
|
const sourceFile = program.getSourceFile('B.ts');
|
|
const metadata = extractor.getMetadata(sourceFile, typeChecker);
|
|
expect(metadata).toEqual({
|
|
__symbolic: 'module',
|
|
module: './B',
|
|
metadata: {
|
|
B: {
|
|
__symbolic: 'class',
|
|
decorators: [
|
|
{
|
|
__symbolic: 'call',
|
|
expression: {__symbolic: 'reference', name: 'Pipe', module: './directives'},
|
|
arguments: [{name: 'some-name', pure: true}]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
it('souce be able to extract metadata that uses external references', () => {
|
|
const sourceFile = program.getSourceFile('C.ts');
|
|
const metadata = extractor.getMetadata(sourceFile, typeChecker);
|
|
expect(metadata).toEqual({
|
|
__symbolic: 'module',
|
|
module: './C',
|
|
metadata: {
|
|
B: {
|
|
__symbolic: 'class',
|
|
decorators: [
|
|
{
|
|
__symbolic: 'call',
|
|
expression: {__symbolic: 'reference', name: 'Pipe', module: './directives'},
|
|
arguments: [
|
|
{
|
|
name: {__symbolic: "reference", module: "./external", name: "externalName"},
|
|
pure:
|
|
{__symbolic: "reference", module: "./external", name: "externalBool"}
|
|
}
|
|
]
|
|
}
|
|
]
|
|
}
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
const files = {
|
|
'directives.ts': `
|
|
export function Pipe(options: { name?: string, pure?: boolean}) {
|
|
return function(fn: Function) { }
|
|
}
|
|
`,
|
|
'consts.ts': `
|
|
export var someName = 'some-name';
|
|
export var someBool = true;
|
|
`,
|
|
'external.d.ts': `
|
|
export const externalName: string;
|
|
export const externalBool: boolean;
|
|
`,
|
|
'A.ts': `
|
|
import {Pipe} from './directives';
|
|
|
|
@Pipe({name: 'A', pure: false})
|
|
export class A {}`,
|
|
'B.ts': `
|
|
import {Pipe} from './directives';
|
|
import {someName, someBool} from './consts';
|
|
|
|
@Pipe({name: someName, pure: someBool})
|
|
export class B {}`,
|
|
'C.ts': `
|
|
import {Pipe} from './directives';
|
|
import {externalName, externalBool} from './external';
|
|
|
|
@Pipe({name: externalName, pure: externalBool})
|
|
export class B {}`
|
|
}
|