fix: fix the ts-estree tests

typescript-eslint · Jul 12, 2019 · 6ddba98 · 6ddba98
1 parent 3f5a6cd
commit 6ddba98
Show file tree

Hide file tree

Showing 3 changed files with 49 additions and 46 deletions.
diff --git a/packages/typescript-estree/src/parser.ts b/packages/typescript-estree/src/parser.ts
@@ -392,7 +392,9 @@ export function parseAndGenerateServices<
    * Convert the TypeScript AST to an ESTree-compatible one, and optionally preserve
    * mappings between converted and original AST nodes
    */
-  const { estree, astMaps } = convert(ast, extra, true);
+  const preserveNodeMaps =
+    typeof extra.preserveNodeMaps === 'boolean' ? extra.preserveNodeMaps : true;
+  const { estree, astMaps } = convert(ast, extra, preserveNodeMaps);
   /**
    * Even if TypeScript parsed the source code ok, and we had no problems converting the AST,
    * there may be other syntactic or semantic issues in the code that we can optionally report on.

diff --git a/packages/typescript-estree/tests/lib/convert.ts b/packages/typescript-estree/tests/lib/convert.ts
@@ -132,8 +132,8 @@ describe('convert', () => {
     instance.convertProgram();
     const maps = instance.getASTMaps();
 
-    function checkMaps(child: any) {
-      child.forEachChild((node: any) => {
+    function checkMaps(child: ts.SourceFile | ts.Node) {
+      child.forEachChild(node => {
         if (
           node.kind !== ts.SyntaxKind.EndOfFileToken &&
           node.kind !== ts.SyntaxKind.JsxAttributes
@@ -160,13 +160,13 @@ describe('convert', () => {
     const instance = new Converter(ast, {
       errorOnUnknownASTType: false,
       useJSXTextNode: false,
-      shouldPreserveNodeMaps: false,
+      shouldPreserveNodeMaps: true,
     });
     const program = instance.convertProgram();
     const maps = instance.getASTMaps();
 
-    function checkMaps(child: any) {
-      child.forEachChild((node: any) => {
+    function checkMaps(child: ts.SourceFile | ts.Node) {
+      child.forEachChild(node => {
         if (node.kind !== ts.SyntaxKind.EndOfFileToken) {
           expect(ast).toBe(
             maps.esTreeNodeToTSNodeMap.get(maps.tsNodeToESTreeNodeMap.get(ast)),

diff --git a/packages/typescript-estree/tests/lib/parse.ts b/packages/typescript-estree/tests/lib/parse.ts
@@ -88,7 +88,7 @@ describe('parse()', () => {
           tokens: expect.any(Array),
           tsconfigRootDir: expect.any(String),
           useJSXTextNode: false,
-          preserveNodeMaps: false,
+          preserveNodeMaps: true,
         },
         false,
       );
@@ -159,72 +159,73 @@ describe('parse()', () => {
       );
     });
 
-    it('should not preserve node maps by default for parseAndGenerateServices(), unless `project` is set', () => {
+    it('should preserve node maps by default for parseAndGenerateServices()', () => {
       const noOptionSet = parser.parseAndGenerateServices(code, baseConfig);
 
-      expect(noOptionSet.services.esTreeNodeToTSNodeMap).toBeUndefined();
-      expect(noOptionSet.services.tsNodeToESTreeNodeMap).toBeUndefined();
-
-      const withProjectNoOptionSet = parser.parseAndGenerateServices(code, {
-        ...baseConfig,
-        project: './tsconfig.json',
-      });
-
-      expect(withProjectNoOptionSet.services.esTreeNodeToTSNodeMap).toEqual(
-        expect.any(WeakMap),
-      );
-      expect(withProjectNoOptionSet.services.tsNodeToESTreeNodeMap).toEqual(
-        expect.any(WeakMap),
-      );
-    });
-
-    it('should preserve node maps for parseAndGenerateServices() when option is `true`, regardless of `project` config', () => {
-      const optionSetToTrue = parser.parseAndGenerateServices(code, {
-        ...baseConfig,
-        preserveNodeMaps: true,
-      });
-
-      expect(optionSetToTrue.services.esTreeNodeToTSNodeMap).toEqual(
+      expect(noOptionSet.services.esTreeNodeToTSNodeMap).toEqual(
         expect.any(WeakMap),
       );
-      expect(optionSetToTrue.services.tsNodeToESTreeNodeMap).toEqual(
+      expect(noOptionSet.services.tsNodeToESTreeNodeMap).toEqual(
         expect.any(WeakMap),
       );
 
-      const withProjectOptionSetToTrue = parser.parseAndGenerateServices(code, {
+      const withProjectNoOptionSet = parser.parseAndGenerateServices(code, {
         ...baseConfig,
-        preserveNodeMaps: true,
         project: './tsconfig.json',
       });
 
-      expect(withProjectOptionSetToTrue.services.esTreeNodeToTSNodeMap).toEqual(
+      expect(withProjectNoOptionSet.services.esTreeNodeToTSNodeMap).toEqual(
         expect.any(WeakMap),
       );
-      expect(withProjectOptionSetToTrue.services.tsNodeToESTreeNodeMap).toEqual(
+      expect(withProjectNoOptionSet.services.tsNodeToESTreeNodeMap).toEqual(
         expect.any(WeakMap),
       );
     });
 
-    it('should not preserve node maps for parseAndGenerateServices() when option is `false`, regardless of `project` config', () => {
+    function checkNodeMaps(setting: boolean): void {
       const optionSetToFalse = parser.parseAndGenerateServices(code, {
         ...baseConfig,
-        preserveNodeMaps: false,
+        preserveNodeMaps: setting,
       });
 
-      expect(optionSetToFalse.services.esTreeNodeToTSNodeMap).toBeUndefined();
-      expect(optionSetToFalse.services.tsNodeToESTreeNodeMap).toBeUndefined();
+      expect(
+        optionSetToFalse.services.esTreeNodeToTSNodeMap.has(
+          optionSetToFalse.ast.body[0],
+        ),
+      ).toBe(setting);
+      expect(
+        optionSetToFalse.services.tsNodeToESTreeNodeMap.has(
+          optionSetToFalse.services.program.getSourceFile('estree.ts'),
+        ),
+      ).toBe(setting);
 
       const withProjectOptionSetToFalse = parser.parseAndGenerateServices(
         code,
-        { ...baseConfig, preserveNodeMaps: false, project: './tsconfig.json' },
+        {
+          ...baseConfig,
+          preserveNodeMaps: setting,
+          project: './tsconfig.json',
+        },
       );
 
       expect(
-        withProjectOptionSetToFalse.services.esTreeNodeToTSNodeMap,
-      ).toBeUndefined();
+        withProjectOptionSetToFalse.services.esTreeNodeToTSNodeMap.has(
+          withProjectOptionSetToFalse.ast.body[0],
+        ),
+      ).toBe(setting);
       expect(
-        withProjectOptionSetToFalse.services.tsNodeToESTreeNodeMap,
-      ).toBeUndefined();
-    });
+        withProjectOptionSetToFalse.services.tsNodeToESTreeNodeMap.has(
+          withProjectOptionSetToFalse.services.program.getSourceFile(
+            'estree.ts',
+          ),
+        ),
+      ).toBe(setting);
+    }
+
+    it('should preserve node maps for parseAndGenerateServices() when option is `true`, regardless of `project` config', () =>
+      checkNodeMaps(true));
+
+    it('should not preserve node maps for parseAndGenerateServices() when option is `false`, regardless of `project` config', () =>
+      checkNodeMaps(false));
   });
 });