fix(valid-expect): allow expect(value, "message")

docs/rules/valid-expect.md

@@ -68,13 +68,16 @@ This rule triggers a warning if `expect` is called with no argument or with more
   - Default: `1`
 
   - Enforce `expect` to be called with at most `maxArgs` arguments.
+  - Exception: `expect(value, "message")` is allowed.
 
 	```js
 	// ✅ good
 	expect(1).toBe(1)
+	expect(1, "expect value to be one").toBe(1)
+    const message = "expect value to be one"
+	expect(1, `Error Message: ${message}`).toBe(1)
 
 
 	// ❌ bad
 	expect(1, 2, 3, 4).toBe(1)
 	```
-

src/rules/valid-expect.ts

@@ -241,6 +241,19 @@ export default createEslintRule<[
         }
 
         if (expect.arguments.length > maxArgs) {
+          // if expect(value, "message") and expect(value, `${message}`), it is valid usage
+          // Note: 2nd argument should be string, not a variable in current implementation
+          if (expect.arguments.length === 2) {
+            //  expect(value, "string literal")
+            const isSecondArgString = expect.arguments[1].type === AST_NODE_TYPES.Literal &&
+              typeof expect.arguments[1].value === 'string';
+            // expect(value, `template literal`)
+            const isSecondArgTemplateLiteral = expect.arguments[1].type === AST_NODE_TYPES.TemplateLiteral;
+            if (isSecondArgString || isSecondArgTemplateLiteral) {
+              return;
+            }
+          }
+
           const { start } = expect.arguments[maxArgs].loc
           const { end } = expect.arguments[expect.arguments.length - 1].loc
 

tests/valid-expect.test.ts

@@ -83,6 +83,9 @@ ruleTester.run(RULE_NAME, rule, {
       }
     });
      `,
+    'expect(value, "message").toBe(1);',
+    'expect(value, `message`).toBe(1);',
+    'const message = "message"; expect(value, `${message}`).toBe(1);',
     {
       code: 'expect(1).toBe(2);',
       options: [{ maxArgs: 2 }]
@@ -150,20 +153,6 @@ ruleTester.run(RULE_NAME, rule, {
         }
       ]
     },
-    {
-      code: 'expect("something", "else").toEqual("something");',
-      errors: [
-        {
-          endColumn: 28,
-          column: 21,
-          messageId: 'tooManyArgs',
-          data: {
-            s: '',
-            amount: 1
-          }
-        }
-      ]
-    },
     {
       code: 'expect("something", "else", "entirely").toEqual("something");',
       options: [{ maxArgs: 2 }],
@@ -236,18 +225,61 @@ ruleTester.run(RULE_NAME, rule, {
             s: 's',
             amount: 3
           }
-        },
+        }
+      ]
+    },
+    // expect() 2nd argument to be a string literal
+    {
+      code: 'expect("something", true).toEqual("something");',
+      errors: [
         {
-          endColumn: 28,
+          endColumn: 26,
           column: 21,
           messageId: 'tooManyArgs',
-          data: {
-            s: '',
-            amount: 1
-          }
         }
       ]
     },
+    {
+      code: 'expect("something", 12).toEqual("something");',
+      errors: [
+        {
+          endColumn: 24,
+          column: 21,
+          messageId: 'tooManyArgs',
+        }
+      ]
+    },
+    {
+      code: 'expect("something", {}).toEqual("something");',
+      errors: [
+        {
+          endColumn: 24,
+          column: 21,
+          messageId: 'tooManyArgs',
+        }
+      ]
+    },
+    {
+      code: 'expect("something", []).toEqual("something");',
+      errors: [
+        {
+          endColumn: 24,
+          column: 21,
+          messageId: 'tooManyArgs',
+        }
+      ]
+    },
+    // expect(value, "string literal") is valid, but expect(value, variable) is not
+    // because the AST does not have type information for variables
+    {
+      code: `const message = "message";
+      expect(1, message).toBe(2);`,
+      errors: [{
+        endColumn: 25,
+        column: 17,
+        messageId: 'tooManyArgs'
+      }]
+    },
     {
       code: 'expect("something");',
       errors: [{ endColumn: 20, column: 1, messageId: 'matcherNotFound' }]