feat(eslint-plugin-jest): add prefer-strict-equal rule

internal/plugins/jest/all.go

@@ -5,6 +5,7 @@ import (
 	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/no_focused_tests"
 	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/no_hooks"
 	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/no_test_prefixes"
+	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/prefer_strict_equal"
 	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/valid_describe_callback"
 	"github.com/web-infra-dev/rslint/internal/rule"
 )
@@ -15,6 +16,7 @@ func GetAllRules() []rule.Rule {
 		no_focused_tests.NoFocusedTestsRule,
 		no_hooks.NoHooksRule,
 		no_test_prefixes.NoTestPrefixesRule,
+		prefer_strict_equal.PreferStrictEqualRule,
 		valid_describe_callback.ValidDescribeCallbackRule,
 	}
 }

internal/plugins/jest/rules/prefer_strict_equal/prefer_strict_equal.go

@@ -0,0 +1,65 @@
+package prefer_strict_equal
+
+import (
+	"github.com/microsoft/typescript-go/shim/ast"
+	"github.com/microsoft/typescript-go/shim/core"
+	"github.com/web-infra-dev/rslint/internal/plugins/jest/utils"
+	"github.com/web-infra-dev/rslint/internal/rule"
+)
+
+// Message Builders
+
+func buildUseToStrictEqualErrorMessage() rule.RuleMessage {
+	return rule.RuleMessage{
+		Id:          "useToStrictEqual",
+		Description: "Use `toStrictEqual()` instead",
+	}
+}
+
+func buildSuggestReplaceWithStrictEqualErrorMessage() rule.RuleMessage {
+	return rule.RuleMessage{
+		Id:          "suggestReplaceWithStrictEqual",
+		Description: "Replace with `toStrictEqual()`",
+	}
+}
+
+var PreferStrictEqualRule = rule.Rule{
+	Name: "jest/prefer-strict-equal",
+	Run: func(ctx rule.RuleContext, options any) rule.RuleListeners {
+		return rule.RuleListeners{
+			ast.KindCallExpression: func(node *ast.Node) {
+				jestFnCall := utils.ParseJestFnCall(node, ctx)
+				if jestFnCall == nil || jestFnCall.Kind != utils.JestFnTypeExpect {
+					return
+				}
+
+				MemberEntries := jestFnCall.MemberEntries
+				if len(MemberEntries) == 0 {
+					return
+				}
+
+				for _, memberEntry := range MemberEntries {
+					kind := memberEntry.Node.Kind
+					if kind != ast.KindIdentifier && kind != ast.KindStringLiteral {
+						continue
+					}
+
+					if memberEntry.Name != "toEqual" {
+						continue
+					}
+
+					ctx.ReportNodeWithSuggestions(
+						memberEntry.Node,
+						buildUseToStrictEqualErrorMessage(),
+						rule.RuleSuggestion{
+							Message: buildSuggestReplaceWithStrictEqualErrorMessage(),
+							FixesArr: []rule.RuleFix{
+								{Range: core.NewTextRange(memberEntry.Node.Pos(), memberEntry.Node.End()), Text: "toStrictEqual"},
+							},
+						},
+					)
+				}
+			},
+		}
+	},
+}

internal/plugins/jest/rules/prefer_strict_equal/prefer_strict_equal.md

@@ -0,0 +1,21 @@
+# jest/prefer-strict-equal
+
+## Rule Details
+
+Prefer `toStrictEqual()` over `toEqual()` on `expect()`. It is common to expect objects to not only have identical values but also to have identical keys. A stricter equality will catch cases where two objects do not have identical keys.
+
+Examples of **incorrect** code for this rule:
+
+```javascript
+expect({ a: 'a', b: undefined }).toEqual({ a: 'a' });
+```
+
+Examples of **correct** code for this rule:
+
+```javascript
+expect({ a: 'a', b: undefined }).toStrictEqual({ a: 'a' });
+```
+
+## Original Documentation
+
+- [jest/prefer-strict-equal](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/prefer-strict-equal.md)

internal/plugins/jest/rules/prefer_strict_equal/prefer_strict_equal_test.go

@@ -0,0 +1,73 @@
+package prefer_strict_equal_test
+
+import (
+	"testing"
+
+	"github.com/web-infra-dev/rslint/internal/plugins/jest/fixtures"
+	"github.com/web-infra-dev/rslint/internal/plugins/jest/rules/prefer_strict_equal"
+	"github.com/web-infra-dev/rslint/internal/rule_tester"
+)
+
+func TestPreferStrictEqualRule(t *testing.T) {
+	rule_tester.RunRuleTester(
+		fixtures.GetRootDir(),
+		"tsconfig.json",
+		t,
+		&prefer_strict_equal.PreferStrictEqualRule,
+		[]rule_tester.ValidTestCase{
+			{Code: `expect(something).toStrictEqual(somethingElse);`},
+			{Code: `a().toEqual('b')`},
+			{Code: `expect(a);`},
+		},
+		[]rule_tester.InvalidTestCase{
+			{
+				Code: `expect(something).toEqual(somethingElse);`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "useToStrictEqual",
+						Line:      1,
+						Column:    19,
+						Suggestions: []rule_tester.InvalidTestCaseSuggestion{
+							{
+								MessageId: "suggestReplaceWithStrictEqual",
+								Output:    `expect(something).toStrictEqual(somethingElse);`,
+							},
+						},
+					},
+				},
+			},
+			{
+				Code: `expect(something).toEqual(somethingElse,);`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "useToStrictEqual",
+						Line:      1,
+						Column:    19,
+						Suggestions: []rule_tester.InvalidTestCaseSuggestion{
+							{
+								MessageId: "suggestReplaceWithStrictEqual",
+								Output:    `expect(something).toStrictEqual(somethingElse,);`,
+							},
+						},
+					},
+				},
+			},
+			{
+				Code: `expect(something)["toEqual"](somethingElse);`,
+				Errors: []rule_tester.InvalidTestCaseError{
+					{
+						MessageId: "useToStrictEqual",
+						Line:      1,
+						Column:    19,
+						Suggestions: []rule_tester.InvalidTestCaseSuggestion{
+							{
+								MessageId: "suggestReplaceWithStrictEqual",
+								Output:    `expect(something)[toStrictEqual](somethingElse);`,
+							},
+						},
+					},
+				},
+			},
+		},
+	)
+}

packages/rslint-test-tools/rstest.config.mts

@@ -244,6 +244,7 @@ export default defineConfig({
     './tests/eslint-plugin-jest/rules/no-focused-tests.test.ts',
     './tests/eslint-plugin-jest/rules/no-hooks.test.ts',
     './tests/eslint-plugin-jest/rules/no-test-prefixes.test.ts',
+    './tests/eslint-plugin-jest/rules/prefer-strict-equal.test.ts',
     './tests/eslint-plugin-jest/rules/valid-describe-callback.test.ts',
   ],
 });

packages/rslint-test-tools/tests/eslint-plugin-jest/rules/prefer-strict-equal.test.ts

@@ -0,0 +1,61 @@
+import { RuleTester } from '../rule-tester';
+
+const ruleTester = new RuleTester();
+
+ruleTester.run('prefer-strict-equal', {} as never, {
+  valid: [
+    { code: 'expect(something).toStrictEqual(somethingElse);' },
+    { code: "a().toEqual('b')" },
+    { code: 'expect(a);' },
+  ],
+  invalid: [
+    {
+      code: 'expect(something).toEqual(somethingElse);',
+      errors: [
+        {
+          messageId: 'useToStrictEqual',
+          column: 19,
+          line: 1,
+          suggestions: [
+            {
+              messageId: 'suggestReplaceWithStrictEqual',
+              output: 'expect(something).toStrictEqual(somethingElse);',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'expect(something).toEqual(somethingElse,);',
+      errors: [
+        {
+          messageId: 'useToStrictEqual',
+          column: 19,
+          line: 1,
+          suggestions: [
+            {
+              messageId: 'suggestReplaceWithStrictEqual',
+              output: 'expect(something).toStrictEqual(somethingElse,);',
+            },
+          ],
+        },
+      ],
+    },
+    {
+      code: 'expect(something)["toEqual"](somethingElse);',
+      errors: [
+        {
+          messageId: 'useToStrictEqual',
+          column: 19,
+          line: 1,
+          suggestions: [
+            {
+              messageId: 'suggestReplaceWithStrictEqual',
+              output: "expect(something)['toStrictEqual'](somethingElse);",
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});