test(expect-expect): use dedent for multi-line cases (#679)

Author: G-Rath

src/rules/__tests__/expect-expect.test.ts

@@ -2,6 +2,7 @@ import {
   AST_NODE_TYPES,
   TSESLint,
 } from '@typescript-eslint/experimental-utils';
+import dedent from 'dedent';
 import resolveFrom from 'resolve-from';
 import rule from '../expect-expect';
 
@@ -19,8 +20,12 @@ ruleTester.run('expect-expect', rule, {
     'it("should pass", () => somePromise().then(() => expect(true).toBeDefined()))',
     'it("should pass", myTest); function myTest() { expect(true).toBeDefined() }',
     {
-      code:
-        'test("should pass", () => { expect(true).toBeDefined(); foo(true).toBe(true); })',
+      code: dedent`
+        test('should pass', () => {
+          expect(true).toBeDefined();
+          foo(true).toBe(true);
+        });
+      `,
       options: [{ assertFunctionNames: ['expect', 'foo'] }],
     },
     {
@@ -32,23 +37,34 @@ ruleTester.run('expect-expect', rule, {
       options: [{ assertFunctionNames: ['expect\\$'] }],
     },
     {
-      code: `test('verifies expect method call', () => new Foo().expect(123));`,
+      code: "test('verifies expect method call', () => new Foo().expect(123));",
       options: [{ assertFunctionNames: ['Foo.expect'] }],
     },
     {
-      code: `test('verifies deep expect method call', () => tester.foo().expect(123));`,
+      code: dedent`
+        test('verifies deep expect method call', () => {
+          tester.foo().expect(123);
+        });
+      `,
       options: [{ assertFunctionNames: ['tester.foo.expect'] }],
     },
     {
-      code: `test('verifies recursive expect method call', () => tester.foo().bar().expect(456));`,
+      code: dedent`
+        test('verifies chained expect method call', () => {
+          tester
+            .foo()
+            .bar()
+            .expect(456);
+        });
+      `,
       options: [{ assertFunctionNames: ['tester.foo.bar.expect'] }],
     },
     {
-      code: [
-        'test("verifies the function call", () => {',
-        '  td.verify(someFunctionCall())',
-        '})',
-      ].join('\n'),
+      code: dedent`
+        test("verifies the function call", () => {
+          td.verify(someFunctionCall())
+        })
+      `,
       options: [{ assertFunctionNames: ['td.verify'] }],
     },
     {
@@ -125,41 +141,41 @@ ruleTester.run('expect-expect', rule, {
 ruleTester.run('wildcards', rule, {
   valid: [
     {
-      code: `test('should pass', () => tester.foo().expect(123));`,
+      code: "test('should pass', () => tester.foo().expect(123));",
       options: [{ assertFunctionNames: ['tester.*.expect'] }],
     },
     {
-      code: `test('should pass **', () => tester.foo().expect(123));`,
+      code: "test('should pass **', () => tester.foo().expect(123));",
       options: [{ assertFunctionNames: ['**'] }],
     },
     {
-      code: `test('should pass *', () => tester.foo().expect(123));`,
+      code: "test('should pass *', () => tester.foo().expect(123));",
       options: [{ assertFunctionNames: ['*'] }],
     },
     {
-      code: `test('should pass', () => tester.foo().expect(123));`,
+      code: "test('should pass', () => tester.foo().expect(123));",
       options: [{ assertFunctionNames: ['tester.**'] }],
     },
     {
-      code: `test('should pass', () => tester.foo().expect(123));`,
+      code: "test('should pass', () => tester.foo().expect(123));",
       options: [{ assertFunctionNames: ['tester.*'] }],
     },
     {
-      code: `test('should pass', () => tester.foo().bar().expectIt(456));`,
+      code: "test('should pass', () => tester.foo().bar().expectIt(456));",
       options: [{ assertFunctionNames: ['tester.**.expect*'] }],
     },
     {
-      code: `test('should pass', () => request.get().foo().expect(456));`,
+      code: "test('should pass', () => request.get().foo().expect(456));",
       options: [{ assertFunctionNames: ['request.**.expect'] }],
     },
     {
-      code: `test('should pass', () => request.get().foo().expect(456));`,
+      code: "test('should pass', () => request.get().foo().expect(456));",
       options: [{ assertFunctionNames: ['request.**.e*e*t'] }],
     },
   ],
   invalid: [
     {
-      code: `test('should fail', () => request.get().foo().expect(456));`,
+      code: "test('should fail', () => request.get().foo().expect(456));",
       options: [{ assertFunctionNames: ['request.*.expect'] }],
       errors: [
         {
@@ -169,7 +185,7 @@ ruleTester.run('wildcards', rule, {
       ],
     },
     {
-      code: `test('should fail', () => request.get().foo().bar().expect(456));`,
+      code: "test('should fail', () => request.get().foo().bar().expect(456));",
       options: [{ assertFunctionNames: ['request.foo**.expect'] }],
       errors: [
         {
@@ -179,7 +195,7 @@ ruleTester.run('wildcards', rule, {
       ],
     },
     {
-      code: `test('should fail', () => tester.request(123));`,
+      code: "test('should fail', () => tester.request(123));",
       options: [{ assertFunctionNames: ['request.*'] }],
       errors: [
         {
@@ -189,7 +205,7 @@ ruleTester.run('wildcards', rule, {
       ],
     },
     {
-      code: `test('should fail', () => request(123));`,
+      code: "test('should fail', () => request(123));",
       options: [{ assertFunctionNames: ['request.*'] }],
       errors: [
         {
@@ -199,7 +215,7 @@ ruleTester.run('wildcards', rule, {
       ],
     },
     {
-      code: `test('should fail', () => request(123));`,
+      code: "test('should fail', () => request(123));",
       options: [{ assertFunctionNames: ['request.**'] }],
       errors: [
         {