Simplify tests

Author: fisker

tests/helpers.ts

@@ -1,41 +1,27 @@
 import * as angular from '@angular/compiler';
 import { codeFrameColumns } from '@babel/code-frame';
-import * as babelParser from '@babel/parser';
-import type * as babel from '@babel/types';
+import * as babel from '@babel/parser';
 import { wrap } from 'jest-snapshot-serializer-raw';
 import { LinesAndColumns } from 'lines-and-columns';
 
-const babelParserOptions: babelParser.ParserOptions = {
+const babelParseOptions: babel.ParserOptions = {
   plugins: [
     'typescript', // NonNullAssert
   ],
   ranges: true,
 };
 
-function fixBabelCommentsRange(
-  ast: (
-    | ReturnType<typeof babelParser.parse>
-    | ReturnType<typeof babelParser.parseExpression>
-  ) & { comments?: babel.Comment[] | null },
-) {
+export const parseBabelExpression = (input: string) => {
+  const ast = babel.parseExpression(input, babelParseOptions);
+
   // https://github.com/babel/babel/issues/15115
   for (const comment of ast.comments!) {
-    // @ts-expect-error -- missing types
+    // @ts-expect-error -- Missing ranges
     comment.range ??= [comment.start, comment.end];
   }
 
   return ast;
-}
-
-export function parseBabelExpression(input: string) {
-  return fixBabelCommentsRange(
-    babelParser.parseExpression(input, babelParserOptions),
-  );
-}
-
-export function parseBabel(input: string) {
-  return fixBabelCommentsRange(babelParser.parse(input, babelParserOptions));
-}
+};
 
 export function massageAst(ast: any, parser: 'babel' | 'angular'): any {
   if (!ast || typeof ast !== 'object') {

tests/transform.test.ts

@@ -1,23 +1,15 @@
 import type * as angular from '@angular/compiler';
-import type * as babelParser from '@babel/parser';
-import type * as babel from '@babel/types';
 
 import * as angularParser from '../src/angular-parser.js';
 import * as estreeParser from '../src/estree-parser.js';
 import type { NGNode } from '../src/types.js';
 import {
   getAngularNodeType,
   massageAst,
-  parseBabel,
   parseBabelExpression,
   snapshotAst,
 } from './helpers.js';
 
-type BabelParseResult = ReturnType<typeof babelParser.parse>;
-type BabelParseExpressionResult = ReturnType<
-  typeof babelParser.parseExpression
->;
-
 const PARSE_METHODS = [
   'parseAction',
   'parseBinding',
@@ -504,56 +496,35 @@ function runTest(testCase: TestCase, method: (typeof PARSE_METHODS)[number]) {
   const parseEstree = estreeParser[method];
 
   if (!isAllowed) {
-    test(`disallowed in ${method}`, () => {
-      expect(() => parseAngular(text)).toThrow();
-      expect(() => parseEstree(text)).toThrow();
-    });
+    test(`disallowed in ${method}`, () => {});
     return;
   }
 
-  let angularNode: angular.AST;
-  let estreeNode: NGNode;
-  let babelNode: (
-    | BabelParseResult
-    | BabelParseExpressionResult
-    | babel.Expression
-  ) & { comments?: babel.Comment[] | null };
+  test(`${method}(${JSON.stringify(text)})`, () => {
+    if (!isAllowed) {
+      expect(() => parseAngular(text)).toThrow();
+      expect(() => parseEstree(text)).toThrow();
+    }
 
-  beforeAll(() => {
-    angularNode = parseAngular(text).result.ast;
+    let angularNode = parseAngular(text).result.ast;
     if (method === 'parseInterpolationExpression') {
       angularNode = (angularNode as angular.Interpolation).expressions[0];
     }
-
-    estreeNode = parseEstree(text);
-    if (!estreeNode.type.startsWith('NG')) {
-      try {
-        babelNode = parseBabelExpression(text);
-      } catch {
-        babelNode = parseBabel(text);
-      }
-    }
-  });
-
-  test(`${method}(${JSON.stringify(text)})`, () => {
     expect(angularNode).toBeDefined();
-    expect(estreeNode).toBeDefined();
-
     expect(getAngularNodeType(angularNode)).toEqual(expectedAngularType);
+
+    const estreeNode = parseEstree(text);
+    expect(estreeNode).toBeDefined();
     expect(estreeNode.type).toEqual(expectedEstreeType);
 
     if (estreeNode.type.startsWith('NG')) {
       expect(snapshotAst(estreeNode, text)).toMatchSnapshot();
       return;
     }
 
+    const babelNode = parseBabelExpression(text);
+
     expect(babelNode).toBeDefined();
-    if (babelNode.type === 'File') {
-      const { comments = [], program } = babelNode;
-      const statement = program.body[0] as babel.ExpressionStatement;
-      expect(statement.type).toEqual('ExpressionStatement');
-      babelNode = { ...statement.expression, comments };
-    }
     expect(massageAst(estreeNode, 'angular')).toEqual(
       massageAst(babelNode, 'babel'),
     );