eslint-plugin-sonarjs 4.0.3 → 4.1.0

package/cjs/S5906/assertion-suggestions.js

@@ -0,0 +1,279 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBooleanExpressionSuggestion = getBooleanExpressionSuggestion;
+exports.chaiShouldReceiver = chaiShouldReceiver;
+const ast_js_1 = require("../helpers/ast.js");
+const assertion_utils_js_1 = require("./assertion-utils.js");
+const STRICT_EQUALITY_OPERATORS = new Set(['===', '!==']);
+const STRING_LIKE_IDENTIFIER = /(?:text|string|message|content|html)$/i;
+const NUMERIC_IDENTIFIER = /(?:amount|count|delta|depth|diff|duration|elapsed|height|index|length|level|limit|number|price|score|size|total|width)$/i;
+const DATE_LIKE_IDENTIFIER = /(?:date|time|timestamp)$/i;
+function getBooleanExpressionSuggestion(actual, positive, family, sourceCode, node, assertObject = 'assert', extraArguments = '') {
+    if (actual.type === 'BinaryExpression') {
+        return getBinaryExpressionSuggestion(actual, positive, family, sourceCode, node, assertObject, extraArguments);
+    }
+    return getIncludesSuggestion(actual, positive, family, sourceCode, node, assertObject, extraArguments);
+}
+function chaiShouldReceiver(source, node) {
+    return isSafeChaiShouldReceiver(node) ? source : `(${source})`;
+}
+const SAFE_CHAI_SHOULD_RECEIVER_TYPES = new Set([
+    'Identifier',
+    'MemberExpression',
+    'CallExpression',
+    'ThisExpression',
+]);
+function isSafeChaiShouldReceiver(node) {
+    return SAFE_CHAI_SHOULD_RECEIVER_TYPES.has(node.type);
+}
+function getBinaryExpressionSuggestion(actual, positive, family, sourceCode, node, assertObject, extraArguments) {
+    const left = sourceCode.getText(actual.left);
+    const right = sourceCode.getText(actual.right);
+    const suggestionContext = { family, sourceCode, node, assertObject, extraArguments };
+    if (STRICT_EQUALITY_OPERATORS.has(actual.operator)) {
+        const same = actual.operator === '===' ? positive : !positive;
+        const specificSuggestion = buildSpecificEqualitySuggestion(actual, same, suggestionContext);
+        if (specificSuggestion !== undefined) {
+            return specificSuggestion;
+        }
+        return buildEqualitySuggestion(actual.left, right, same, suggestionContext);
+    }
+    if (actual.operator === 'instanceof') {
+        return buildInstanceofSuggestion(left, actual.left, right, positive, suggestionContext);
+    }
+    const comparison = isNumericComparison(actual)
+        ? getNumericComparison(actual.operator, positive)
+        : null;
+    if (comparison) {
+        return buildNumericComparisonSuggestion(left, actual.left, right, comparison, suggestionContext);
+    }
+    return null;
+}
+function buildSpecificEqualitySuggestion(actual, same, context) {
+    const leftNullish = getNullishKind(actual.left);
+    if (leftNullish) {
+        return buildNullishEqualitySuggestion(actual.right, leftNullish, same, context);
+    }
+    const rightNullish = getNullishKind(actual.right);
+    if (rightNullish) {
+        return buildNullishEqualitySuggestion(actual.left, rightNullish, same, context);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual.left)) {
+        return buildLengthEqualitySuggestion(actual.left.object, context.sourceCode.getText(actual.right), same, context);
+    }
+    if ((0, assertion_utils_js_1.isLengthAccess)(actual.right)) {
+        return buildLengthEqualitySuggestion(actual.right.object, context.sourceCode.getText(actual.left), same, context);
+    }
+    return undefined;
+}
+function getNullishKind(node) {
+    if ((0, assertion_utils_js_1.isNullLiteral)(node)) {
+        return 'null';
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(node)) {
+        return 'undefined';
+    }
+    return null;
+}
+function buildNullishEqualitySuggestion(actualNode, nullish, same, context) {
+    const { family, sourceCode, node, assertObject, extraArguments } = context;
+    const actual = sourceCode.getText(actualNode);
+    if (family === 'jest' || family === 'jasmine') {
+        if (nullish === 'null') {
+            return (0, assertion_utils_js_1.replacement)(`expect(${actual})${negation(same)}.toBeNull()`, node);
+        }
+        return (0, assertion_utils_js_1.replacement)(same ? `expect(${actual}).toBeUndefined()` : `expect(${actual}).toBeDefined()`, node);
+    }
+    if (family === 'assert') {
+        const method = getAssertNullishMethod(nullish, same);
+        return (0, assertion_utils_js_1.replacement)(`${assertObject}.${method}(${actual}${extraArguments})`, node);
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(actual, actualNode)}.should${negation(same)}.be.${nullish}`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${actual}${extraArguments}).to${negation(same)}.be.${nullish}`, node);
+}
+function getAssertNullishMethod(nullish, same) {
+    if (nullish === 'null') {
+        return same ? 'isNull' : 'isNotNull';
+    }
+    return same ? 'isUndefined' : 'isDefined';
+}
+function buildLengthEqualitySuggestion(actualNode, expected, same, context) {
+    const { family, sourceCode, node, assertObject, extraArguments } = context;
+    const actual = sourceCode.getText(actualNode);
+    if (family === 'jest' || family === 'jasmine') {
+        const matcher = family === 'jasmine' ? 'toHaveSize' : 'toHaveLength';
+        return (0, assertion_utils_js_1.replacement)(`expect(${actual})${negation(same)}.${matcher}(${expected})`, node);
+    }
+    if (family === 'assert') {
+        return same
+            ? (0, assertion_utils_js_1.replacement)(`${assertObject}.lengthOf(${actual}, ${expected}${extraArguments})`, node)
+            : null;
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(actual, actualNode)}.should${negation(same)}.have.lengthOf(${expected})`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${actual}${extraArguments}).to${negation(same)}.have.lengthOf(${expected})`, node);
+}
+function buildEqualitySuggestion(leftNode, right, same, context) {
+    const { family, sourceCode, node, assertObject, extraArguments } = context;
+    const left = sourceCode.getText(leftNode);
+    if (family === 'jest' || family === 'jasmine') {
+        return (0, assertion_utils_js_1.replacement)(`expect(${left})${negation(same)}.toBe(${right})`, node);
+    }
+    if (family === 'assert') {
+        return (0, assertion_utils_js_1.replacement)(`${assertObject}.${same ? 'strictEqual' : 'notStrictEqual'}(${left}, ${right}${extraArguments})`, node);
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(left, leftNode)}.should${negation(same)}.equal(${right})`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${left}${extraArguments}).to${negation(same)}.equal(${right})`, node);
+}
+function buildInstanceofSuggestion(left, leftNode, right, positive, context) {
+    const { family, node, assertObject, extraArguments } = context;
+    if (family === 'jest' || family === 'jasmine') {
+        return (0, assertion_utils_js_1.replacement)(`expect(${left})${negation(positive)}.toBeInstanceOf(${right})`, node);
+    }
+    if (family === 'assert') {
+        return (0, assertion_utils_js_1.replacement)(`${assertObject}.${positive ? 'instanceOf' : 'notInstanceOf'}(${left}, ${right}${extraArguments})`, node);
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(left, leftNode)}.should${negation(positive)}.be.instanceOf(${right})`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${left}${extraArguments}).to${negation(positive)}.be.instanceOf(${right})`, node);
+}
+function buildNumericComparisonSuggestion(left, leftNode, right, comparison, context) {
+    const { family, node, assertObject, extraArguments } = context;
+    if (family === 'jest' || family === 'jasmine') {
+        return (0, assertion_utils_js_1.replacement)(`expect(${left}).${comparison.jest}(${right})`, node);
+    }
+    if (family === 'assert') {
+        return (0, assertion_utils_js_1.replacement)(`${assertObject}.${comparison.assert}(${left}, ${right}${extraArguments})`, node);
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(left, leftNode)}.should.be.${comparison.chai}(${right})`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${left}${extraArguments}).to.be.${comparison.chai}(${right})`, node);
+}
+function getIncludesSuggestion(actual, positive, family, sourceCode, node, assertObject, extraArguments) {
+    if (actual.type !== 'CallExpression' ||
+        !(0, ast_js_1.isMethodCall)(actual) ||
+        !(0, ast_js_1.isIdentifier)(actual.callee.property, 'includes') ||
+        actual.arguments.length !== 1 ||
+        !isTrustedStringReceiver(actual.callee.object)) {
+        return null;
+    }
+    const receiver = sourceCode.getText(actual.callee.object);
+    const needle = sourceCode.getText(actual.arguments[0]);
+    if (family === 'jest' || family === 'jasmine') {
+        return (0, assertion_utils_js_1.replacement)(`expect(${receiver})${negation(positive)}.toContain(${needle})`, node);
+    }
+    if (family === 'assert') {
+        return (0, assertion_utils_js_1.replacement)(`${assertObject}.${positive ? 'include' : 'notInclude'}(${receiver}, ${needle}${extraArguments})`, node);
+    }
+    if (family === 'chai-should') {
+        return (0, assertion_utils_js_1.replacement)(`${chaiShouldReceiver(receiver, actual.callee.object)}.should${negation(positive)}.include(${needle})`, node);
+    }
+    return (0, assertion_utils_js_1.replacement)(`expect(${receiver}${extraArguments}).to${negation(positive)}.include(${needle})`, node);
+}
+function negation(positive) {
+    return positive ? '' : '.not';
+}
+function isTrustedStringReceiver(node) {
+    if (node.type === 'Literal') {
+        return typeof node.value === 'string';
+    }
+    if (node.type === 'TemplateLiteral') {
+        return node.expressions.length === 0;
+    }
+    return (0, ast_js_1.isIdentifier)(node) && STRING_LIKE_IDENTIFIER.test(node.name);
+}
+function isNumericComparison(node) {
+    return (isKnownNumericOperand(node.left) &&
+        isKnownNumericOperand(node.right) &&
+        !isKnownNonNumericOperand(node.left) &&
+        !isKnownNonNumericOperand(node.right));
+}
+function isKnownNumericOperand(node) {
+    if (node.type === 'Literal') {
+        return typeof node.value === 'number' || typeof node.value === 'bigint';
+    }
+    if (node.type === 'UnaryExpression' && ['+', '-'].includes(node.operator)) {
+        return isKnownNumericOperand(node.argument);
+    }
+    if ((0, ast_js_1.isIdentifier)(node)) {
+        return NUMERIC_IDENTIFIER.test(node.name);
+    }
+    if (node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property)) {
+        return NUMERIC_IDENTIFIER.test(node.property.name);
+    }
+    return false;
+}
+function isKnownNonNumericOperand(node) {
+    if (node.type === 'Literal') {
+        return typeof node.value === 'string';
+    }
+    if (node.type === 'TemplateLiteral') {
+        return node.expressions.length === 0;
+    }
+    if (node.type === 'NewExpression' && (0, ast_js_1.isIdentifier)(node.callee, 'Date')) {
+        return true;
+    }
+    if (node.type === 'CallExpression' && (0, ast_js_1.isIdentifier)(node.callee, 'Date')) {
+        return true;
+    }
+    if ((0, ast_js_1.isIdentifier)(node)) {
+        return STRING_LIKE_IDENTIFIER.test(node.name) || DATE_LIKE_IDENTIFIER.test(node.name);
+    }
+    if (node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property)) {
+        return (STRING_LIKE_IDENTIFIER.test(node.property.name) ||
+            DATE_LIKE_IDENTIFIER.test(node.property.name));
+    }
+    return false;
+}
+function getNumericComparison(operator, positive) {
+    const effective = positive ? operator : invertComparison(operator);
+    switch (effective) {
+        case '>':
+            return { jest: 'toBeGreaterThan', chai: 'above', assert: 'isAbove' };
+        case '>=':
+            return { jest: 'toBeGreaterThanOrEqual', chai: 'at.least', assert: 'isAtLeast' };
+        case '<':
+            return { jest: 'toBeLessThan', chai: 'below', assert: 'isBelow' };
+        case '<=':
+            return { jest: 'toBeLessThanOrEqual', chai: 'at.most', assert: 'isAtMost' };
+        default:
+            return null;
+    }
+}
+function invertComparison(operator) {
+    switch (operator) {
+        case '>':
+            return '<=';
+        case '>=':
+            return '<';
+        case '<':
+            return '>=';
+        case '<=':
+            return '>';
+        default:
+            return null;
+    }
+}

package/cjs/S5906/assertion-utils.js

@@ -0,0 +1,103 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlaywrightLocatorExpression = isPlaywrightLocatorExpression;
+exports.trackPlaywrightLocators = trackPlaywrightLocators;
+exports.isLengthAccess = isLengthAccess;
+exports.isNullLiteral = isNullLiteral;
+exports.isUndefinedExpression = isUndefinedExpression;
+exports.isNaNExpression = isNaNExpression;
+exports.getBooleanValue = getBooleanValue;
+exports.replacement = replacement;
+const ast_js_1 = require("../helpers/ast.js");
+const PLAYWRIGHT_LOCATOR_FACTORIES = new Set([
+    'getByRole',
+    'getByText',
+    'getByLabel',
+    'getByPlaceholder',
+    'getByAltText',
+    'getByTitle',
+    'getByTestId',
+    'locator',
+    'frameLocator',
+]);
+function isPlaywrightLocatorExpression(context, node, locatorVariables) {
+    if ((0, ast_js_1.isIdentifier)(node)) {
+        const variable = (0, ast_js_1.getVariableFromName)(context, node.name, node);
+        return variable !== undefined && locatorVariables.has(variable);
+    }
+    if (node.type !== 'CallExpression' || !(0, ast_js_1.isMethodCall)(node)) {
+        return false;
+    }
+    const property = node.callee.property;
+    return ((0, ast_js_1.isIdentifier)(property) &&
+        PLAYWRIGHT_LOCATOR_FACTORIES.has(property.name) &&
+        isPlaywrightLocatorRoot(context, node.callee.object, locatorVariables));
+}
+function isPlaywrightLocatorRoot(context, node, locatorVariables) {
+    if ((0, ast_js_1.isIdentifier)(node)) {
+        if (node.name === 'page') {
+            return true;
+        }
+        const variable = (0, ast_js_1.getVariableFromName)(context, node.name, node);
+        return variable !== undefined && locatorVariables.has(variable);
+    }
+    return isPlaywrightLocatorExpression(context, node, locatorVariables);
+}
+// As soon as a third rule consumes this, promote it out of S5906/ into a
+// shared module under helpers/ (e.g. helpers/playwright-locators.ts) so it no
+// longer lives under a specific rule's directory.
+function trackPlaywrightLocators(context, locators) {
+    return {
+        VariableDeclarator(node) {
+            if (node.type !== 'VariableDeclarator' || !(0, ast_js_1.isIdentifier)(node.id)) {
+                return;
+            }
+            if (node.init && isPlaywrightLocatorExpression(context, node.init, locators)) {
+                const variable = context.sourceCode.getDeclaredVariables(node)[0];
+                if (variable) {
+                    locators.add(variable);
+                }
+            }
+        },
+    };
+}
+function isLengthAccess(node) {
+    return (node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property, 'length'));
+}
+function isNullLiteral(node) {
+    return node.type === 'Literal' && node.value === null;
+}
+function isUndefinedExpression(node) {
+    return (0, ast_js_1.isIdentifier)(node, 'undefined');
+}
+function isNaNExpression(node) {
+    return ((0, ast_js_1.isIdentifier)(node, 'NaN') ||
+        (node.type === 'MemberExpression' &&
+            (0, ast_js_1.isIdentifier)(node.object, 'Number') &&
+            (0, ast_js_1.isIdentifier)(node.property, 'NaN')));
+}
+function getBooleanValue(node) {
+    return node.type === 'Literal' && typeof node.value === 'boolean' ? node.value : undefined;
+}
+function replacement(replacementText, _node, _sourceCode) {
+    return {
+        assertion: replacementText,
+        replacement: replacementText,
+    };
+}

package/cjs/S5906/cypress-suggestions.js

@@ -0,0 +1,62 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCypressSuggestion = getCypressSuggestion;
+const ast_js_1 = require("../helpers/ast.js");
+const assertion_utils_js_1 = require("./assertion-utils.js");
+function getCypressSuggestion(node, sourceCode) {
+    if (!(0, ast_js_1.isMethodCall)(node) ||
+        !['should', 'and'].includes(node.callee.property.name) ||
+        node.arguments.length !== 2) {
+        return null;
+    }
+    if (!hasCyWrapCall(node.callee.object) || node.arguments[0].type !== 'Literal') {
+        return null;
+    }
+    const chainer = node.arguments[0].value;
+    const expected = node.arguments[1];
+    const property = node.callee.property.name;
+    const subject = sourceCode.getText(node.callee.object);
+    if ((0, assertion_utils_js_1.isNullLiteral)(expected)) {
+        return getCypressNullishSuggestion(node, sourceCode, chainer, subject, property, 'null');
+    }
+    if ((0, assertion_utils_js_1.isUndefinedExpression)(expected)) {
+        return getCypressNullishSuggestion(node, sourceCode, chainer, subject, property, 'undefined');
+    }
+    return null;
+}
+function getCypressNullishSuggestion(node, sourceCode, chainer, subject, property, nullish) {
+    if (chainer !== 'equal' &&
+        chainer !== 'not.equal' &&
+        chainer !== 'deep.equal' &&
+        chainer !== 'not.deep.equal') {
+        return null;
+    }
+    const negation = chainer === 'not.equal' || chainer === 'not.deep.equal' ? 'not.' : '';
+    return (0, assertion_utils_js_1.replacement)(`${subject}.${property}('${negation}be.${nullish}')`, node, sourceCode);
+}
+function hasCyWrapCall(node) {
+    if (node.type === 'CallExpression' && (0, ast_js_1.isMethodCall)(node)) {
+        return (((0, ast_js_1.isIdentifier)(node.callee.property, 'wrap') && (0, ast_js_1.isIdentifier)(node.callee.object, 'cy')) ||
+            hasCyWrapCall(node.callee.object));
+    }
+    if (node.type === 'MemberExpression' && !node.computed) {
+        return hasCyWrapCall(node.object);
+    }
+    return false;
+}

package/cjs/S5906/expect-chain.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getExpectChain = getExpectChain;
+const ast_js_1 = require("../helpers/ast.js");
+function getExpectChain(node) {
+    if (node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property, 'not')) {
+        const chain = getExpectChain(node.object);
+        return chain ? { ...chain, negated: !chain.negated } : null;
+    }
+    if (node.type !== 'CallExpression' ||
+        !(0, ast_js_1.isIdentifier)(node.callee, 'expect') ||
+        node.arguments.length !== 1) {
+        return null;
+    }
+    return { actual: node.arguments[0], negated: false };
+}

package/cjs/S5906/generated-meta.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+// https://sonarsource.github.io/rspec/#/rspec/S5906/javascript
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipOnGeneratedSource = exports.requiredDependency = exports.languages = exports.scope = exports.sonarKey = exports.meta = void 0;
+__exportStar(require("./meta.js"), exports);
+exports.meta = {
+    type: 'suggestion',
+    docs: {
+        description: 'The most specific assertion should be used',
+        recommended: true,
+        url: 'https://sonarsource.github.io/rspec/#/rspec/S5906/javascript',
+        requiresTypeChecking: false,
+    },
+    fixable: 'code',
+    deprecated: false,
+    defaultOptions: [],
+};
+exports.sonarKey = 'S5906';
+exports.scope = 'Tests';
+exports.languages = ['js', 'ts'];
+exports.requiredDependency = [];
+exports.skipOnGeneratedSource = false;

package/cjs/S5906/meta.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eslintId = exports.implementation = void 0;
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+exports.implementation = 'original';
+exports.eslintId = 'prefer-specific-assertions';

package/cjs/S5906/playwright-suggestions.js

@@ -0,0 +1,103 @@
+"use strict";
+/*
+ * SonarQube JavaScript Plugin
+ * Copyright (C) SonarSource Sàrl
+ * mailto:info AT sonarsource DOT com
+ *
+ * You can redistribute and/or modify this program under the terms of
+ * the Sonar Source-Available License Version 1, as published by SonarSource Sàrl.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the Sonar Source-Available License for more details.
+ *
+ * You should have received a copy of the Sonar Source-Available License
+ * along with this program; if not, see https://sonarsource.com/license/ssal/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPlaywrightLocatorSuggestion = getPlaywrightLocatorSuggestion;
+const ast_js_1 = require("../helpers/ast.js");
+const module_js_1 = require("../helpers/module.js");
+const assertion_utils_js_1 = require("./assertion-utils.js");
+const expect_chain_js_1 = require("./expect-chain.js");
+const PLAYWRIGHT_BOOLEAN_GETTERS = new Map([
+    ['isVisible', { truthy: 'toBeVisible', falsy: 'toBeHidden' }],
+    ['isHidden', { truthy: 'toBeHidden', falsy: 'toBeVisible' }],
+    ['isEnabled', { truthy: 'toBeEnabled', falsy: 'toBeDisabled' }],
+    ['isDisabled', { truthy: 'toBeDisabled', falsy: 'toBeEnabled' }],
+    ['isChecked', { truthy: 'toBeChecked', falsy: 'not.toBeChecked' }],
+]);
+const PLAYWRIGHT_VALUE_GETTERS = new Map([
+    ['count', 'toHaveCount'],
+    ['inputValue', 'toHaveValue'],
+]);
+function getPlaywrightLocatorSuggestion(context, node, sourceCode, locatorVariables) {
+    const chain = getPlaywrightAssertionChain(context, node);
+    if (!chain) {
+        return null;
+    }
+    const { getter, locator, negated } = chain;
+    if (!(0, assertion_utils_js_1.isPlaywrightLocatorExpression)(context, locator, locatorVariables)) {
+        return null;
+    }
+    return (getBooleanGetterSuggestion(getter, locator, node.arguments[0], negated, sourceCode) ??
+        getValueGetterSuggestion(getter, locator, node.arguments[0], negated, sourceCode));
+}
+function getPlaywrightAssertionChain(context, node) {
+    if (!(0, ast_js_1.isMethodCall)(node) ||
+        !['toBe', 'toEqual', 'toStrictEqual'].includes(node.callee.property.name) ||
+        node.arguments.length !== 1) {
+        return null;
+    }
+    if (!isPlaywrightExpect(context, node.callee.object)) {
+        return null;
+    }
+    const chain = (0, expect_chain_js_1.getExpectChain)(node.callee.object);
+    const awaited = chain?.actual.type === 'AwaitExpression' ? chain.actual.argument : undefined;
+    if (!chain || awaited?.type !== 'CallExpression' || !(0, ast_js_1.isMethodCall)(awaited)) {
+        return null;
+    }
+    if (awaited.arguments.length !== 0) {
+        return null;
+    }
+    return { getter: awaited, locator: awaited.callee.object, negated: chain.negated };
+}
+function isPlaywrightExpect(context, node) {
+    const expectCall = getExpectCall(node);
+    return (expectCall !== null &&
+        (0, module_js_1.getFullyQualifiedName)(context, expectCall.callee) === '@playwright.test.expect');
+}
+function getExpectCall(node) {
+    if (node.type === 'MemberExpression' && !node.computed && (0, ast_js_1.isIdentifier)(node.property, 'not')) {
+        return getExpectCall(node.object);
+    }
+    if (node.type === 'CallExpression' && (0, ast_js_1.isIdentifier)(node.callee, 'expect')) {
+        return node;
+    }
+    return null;
+}
+function getBooleanGetterSuggestion(getter, locator, expected, negated, sourceCode) {
+    if (!(0, ast_js_1.isMethodCall)(getter)) {
+        return null;
+    }
+    const matcher = PLAYWRIGHT_BOOLEAN_GETTERS.get(getter.callee.property.name);
+    const expectedBoolean = (0, assertion_utils_js_1.getBooleanValue)(expected);
+    if (!matcher || expectedBoolean === undefined) {
+        return null;
+    }
+    const method = expectedBoolean === negated ? matcher.falsy : matcher.truthy;
+    return { assertion: `await expect(${sourceCode.getText(locator)}).${method}()` };
+}
+function getValueGetterSuggestion(getter, locator, expected, negated, sourceCode) {
+    if (!(0, ast_js_1.isMethodCall)(getter)) {
+        return null;
+    }
+    const matcher = PLAYWRIGHT_VALUE_GETTERS.get(getter.callee.property.name);
+    if (!matcher) {
+        return null;
+    }
+    return {
+        assertion: `await expect(${sourceCode.getText(locator)}).${negated ? 'not.' : ''}${matcher}(${sourceCode.getText(expected)})`,
+    };
+}