Improve expect parsing

src/rules/no-conditional-expect.test.ts

@@ -1,22 +1,36 @@
-import dedent from 'dedent'
 import rule from '../../src/rules/no-conditional-expect'
-import { runRuleTester } from '../utils/rule-tester'
+import { javascript, runRuleTester } from '../utils/rule-tester'
 
 const messageId = 'conditionalExpect'
 
 runRuleTester('common tests', rule, {
   invalid: [],
   valid: [
-    `
+    javascript`
       test('foo', () => {
         expect(1).toBe(2);
       });
     `,
-    `
+    javascript`
       test('foo', () => {
         expect(!true).toBe(false);
       });
     `,
+    {
+      code: javascript`
+        test('foo', () => {
+          const expected = arr.map((x) => {
+            if (typeof x === 'string') {
+              return expect.arrayContaining([x])
+            } else {
+              return b
+            }
+          })
+
+          expect([1, 2, 3]).toEqual(expected);
+        });
+      `,
+    },
   ],
 })
 
@@ -154,7 +168,7 @@ runRuleTester('logical conditions', rule, {
     `,
     // Global aliases
     {
-      code: dedent`
+      code: javascript`
         it('foo', () => {
           process.env.FAIL && setNum(1);
 
@@ -331,7 +345,6 @@ runRuleTester('catch conditions', rule, {
       code: `
         test('foo', () => {
           try {
-
           } catch (err) {
             expect(err).toMatch('Error');
           }
@@ -397,7 +410,7 @@ runRuleTester('catch conditions', rule, {
 runRuleTester('promises', rule, {
   invalid: [
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await Promise.resolve()
             .then(() => { throw new Error('oh noes!'); })
@@ -407,7 +420,7 @@ runRuleTester('promises', rule, {
       errors: [{ messageId }],
     },
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await Promise.resolve()
             .then(() => { throw new Error('oh noes!'); })
@@ -421,7 +434,7 @@ runRuleTester('promises', rule, {
       errors: [{ messageId }],
     },
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await Promise.resolve()
             .catch(error => expect(error).toBeInstanceOf(Error))
@@ -432,7 +445,7 @@ runRuleTester('promises', rule, {
       errors: [{ messageId }],
     },
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await Promise.resolve()
             .catch(error => expect(error).toBeInstanceOf(Error))
@@ -444,7 +457,7 @@ runRuleTester('promises', rule, {
       errors: [{ messageId }],
     },
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await somePromise
             .then(() => { throw new Error('oh noes!'); })
@@ -454,7 +467,7 @@ runRuleTester('promises', rule, {
       errors: [{ messageId }],
     },
     {
-      code: dedent`
+      code: javascript`
         test('works', async () => {
           await somePromise.catch(error => expect(error).toBeInstanceOf(Error));
         });

src/rules/valid-expect.test.ts

@@ -215,6 +215,11 @@ runRuleTester('valid-expect', rule, {
   valid: [
     { code: 'expectPayButtonToBeEnabled()' },
     { code: 'expect("something").toBe("else")' },
+    { code: 'expect.anything()' },
+    { code: 'expect.arrayContaining()' },
+    { code: 'expect.not.arrayContaining()' },
+    { code: 'expect.objectContaining(expected)' },
+    { code: 'expect.not.objectContaining(expected)' },
     { code: 'expect("something").toBe(expect.anything())' },
     { code: 'expect("something").toEqual({ foo: expect.anything() })' },
     { code: 'expect("something").toBe(expect.arrayContaining([1, 2, 3]))' },

src/utils/parseFnCall.test.ts

@@ -260,36 +260,6 @@ runRuleTester('expect', rule, {
       code: dedent`
         import { expect } from '@playwright/test';
 
-        expect.assertions();
-      `,
-      errors: [
-        {
-          column: 1,
-          data: expectedParsedFnCallResultData({
-            args: [],
-            group: 'expect',
-            head: {
-              local: 'expect',
-              node: 'expect',
-              original: null,
-            },
-            matcher: 'assertions',
-            matcherArgs: [],
-            matcherName: 'assertions',
-            members: ['assertions'],
-            modifiers: [],
-            name: 'expect',
-            type: 'expect',
-          }),
-          line: 3,
-          messageId: 'details',
-        },
-      ],
-    },
-    {
-      code: dedent`
-        import { expect } from '@playwright/test';
-
         expect(x).toBe(y);
       `,
       errors: [
@@ -380,58 +350,6 @@ runRuleTester('expect', rule, {
       code: dedent`
         import { expect } from '@playwright/test';
 
-        expect.anything();
-        expect.not.arrayContaining();
-      `,
-      errors: [
-        {
-          column: 1,
-          data: expectedParsedFnCallResultData({
-            args: [],
-            group: 'expect',
-            head: {
-              local: 'expect',
-              node: 'expect',
-              original: null,
-            },
-            matcher: 'anything',
-            matcherArgs: [],
-            matcherName: 'anything',
-            members: ['anything'],
-            modifiers: [],
-            name: 'expect',
-            type: 'expect',
-          }),
-          line: 3,
-          messageId: 'details',
-        },
-        {
-          column: 1,
-          data: expectedParsedFnCallResultData({
-            args: [],
-            group: 'expect',
-            head: {
-              local: 'expect',
-              node: 'expect',
-              original: null,
-            },
-            matcher: 'arrayContaining',
-            matcherArgs: [],
-            matcherName: 'arrayContaining',
-            members: ['not', 'arrayContaining'],
-            modifiers: ['not'],
-            name: 'expect',
-            type: 'expect',
-          }),
-          line: 4,
-          messageId: 'details',
-        },
-      ],
-    },
-    {
-      code: dedent`
-        import { expect } from '@playwright/test';
-
         expect;
         expect(x);
         expect(x).toBe;
@@ -1187,5 +1105,18 @@ runTSRuleTester('typescript', rule, {
     },
     "it('is not a  function', () => {});",
     'dedent()',
+    'expect.assertions()',
+    'expect.anything()',
+    'expect.arrayContaining()',
+    'expect.objectContaining(expected)',
+    'expect.not.objectContaining(expected)',
+    {
+      code: dedent`
+        import { expect } from '@playwright/test';
+
+        expect.assertions();
+        expect.anything();
+      `,
+    },
   ],
 })