4748569255

Build Type

push

github

Committed by GitHub

Commit Message

Upgrade: Bump eslint from 8.36.0 to 8.38.0 (#335)

Run Details

653 of 653 branches covered (100.0%)

878 of 878 relevant lines covered (100.0%)

82.69 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/lib/rules/no-assert-equal.js

/**
 * @fileoverview Forbid the use of assert.equal and suggest other assertions.
 * @author Kevin Partington
 */
"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const assert = require("assert"),
    utils = require("../utils"),
    { ReferenceTracker } = require("eslint-utils");

//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------

/** @type {import('eslint').Rule.RuleModule} */
module.exports = {
    meta: {
        type: "suggestion",
        docs: {
            description: "disallow the use of assert.equal",
            category: "Best Practices",
            url: "https://github.com/platinumazure/eslint-plugin-qunit/blob/master/docs/rules/no-assert-equal.md"
        },
        messages: {
            unexpectedGlobalEqual: "Unexpected equal. Use strictEqual, deepEqual, or propEqual.",
            unexpectedAssertEqual: "Unexpected {{assertVar}}.equal. Use {{assertVar}}.strictEqual, {{assertVar}}.deepEqual, or {{assertVar}}.propEqual.",
            switchToDeepEqual: "Switch to deepEqual.",
            switchToPropEqual: "Switch to propEqual.",
            switchToStrictEqual: "Switch to strictEqual."
        },
        schema: [],
        hasSuggestions: true
    },

    create: function (context) {
        // Declare a test stack in case of nested test cases (not currently
        // supported by QUnit).
        const testStack = [];

        // We check upfront to find all the references to global equal(),
        // and then report them if they end up being inside test contexts.
        const globalEqualCallNodes = new Set();

        function getCurrentAssertContextVariable() {
            assert(testStack.length, "Test stack should not be empty");

            return testStack[testStack.length - 1].assertVar;
        }

        function isAssertEqual(calleeNode) {
            return calleeNode &&
                calleeNode.type === "MemberExpression" &&
                calleeNode.property.type === "Identifier" &&
                calleeNode.property.name === "equal" &&
                calleeNode.object.type === "Identifier" &&
                calleeNode.object.name === getCurrentAssertContextVariable();
        }

        function reportError(node, isGlobal) {
            context.report({
                node: node,
                messageId: isGlobal ? "unexpectedGlobalEqual" : "unexpectedAssertEqual",
                data: {
                    assertVar: isGlobal ? null : getCurrentAssertContextVariable()
                },
                suggest: [
                    {
                        messageId: "switchToDeepEqual",
                        fix(fixer) {
                            return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "deepEqual");
                        }
                    },
                    {
                        messageId: "switchToPropEqual",
                        fix(fixer) {
                            return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "propEqual");
                        }
                    },
                    {
                        messageId: "switchToStrictEqual",
                        fix(fixer) {
                            return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "strictEqual");
                        }
                    }
                ]

            });
        }

        return {
            "CallExpression": function (node) {
                /* istanbul ignore else: correctly does nothing */
                if (utils.isTest(node.callee) || utils.isAsyncTest(node.callee)) {
                    testStack.push({
                        assertVar: utils.getAssertContextNameForTest(node.arguments)
                    });
                } else if (testStack.length > 0) {
                    if (isAssertEqual(node.callee)) {
                        reportError(node, false);
                    } else if (globalEqualCallNodes.has(node)) {
                        reportError(node, true);
                    }
                }
            },
            "CallExpression:exit": function (node) {
                /* istanbul ignore else: correctly does nothing */
                if (utils.isTest(node.callee) || utils.isAsyncTest(node.callee)) {
                    testStack.pop();
                }
            },
            "Program": function () {
                // Gather all calls to global `equal()`.

                const tracker = new ReferenceTracker(context.getScope());
                const traceMap = { equal: { [ReferenceTracker.CALL]: true } };

                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
                    globalEqualCallNodes.add(node);
                }
            }
        };
    }
};

1	/**
2	* @fileoverview Forbid the use of assert.equal and suggest other assertions.
3	* @author Kevin Partington
4	*/
5	"use strict";
6
7	//------------------------------------------------------------------------------
8	// Requirements
9	//------------------------------------------------------------------------------
10
11	const assert = require("assert"),	1✔
12	utils = require("../utils"),	1✔
13	{ ReferenceTracker } = require("eslint-utils");	1✔
14
15	//------------------------------------------------------------------------------
16	// Rule Definition
17	//------------------------------------------------------------------------------
18
19	/** @type {import('eslint').Rule.RuleModule} */
20	module.exports = {	1✔
21	meta: {
22	type: "suggestion",
23	docs: {
24	description: "disallow the use of assert.equal",
25	category: "Best Practices",
26	url: "https://github.com/platinumazure/eslint-plugin-qunit/blob/master/docs/rules/no-assert-equal.md"
27	},
28	messages: {
29	unexpectedGlobalEqual: "Unexpected equal. Use strictEqual, deepEqual, or propEqual.",
30	unexpectedAssertEqual: "Unexpected {{assertVar}}.equal. Use {{assertVar}}.strictEqual, {{assertVar}}.deepEqual, or {{assertVar}}.propEqual.",
31	switchToDeepEqual: "Switch to deepEqual.",
32	switchToPropEqual: "Switch to propEqual.",
33	switchToStrictEqual: "Switch to strictEqual."
34	},
35	schema: [],
36	hasSuggestions: true
37	},
38
39	create: function (context) {
40	// Declare a test stack in case of nested test cases (not currently
41	// supported by QUnit).
42	const testStack = [];	21✔
43
44	// We check upfront to find all the references to global equal(),
45	// and then report them if they end up being inside test contexts.
46	const globalEqualCallNodes = new Set();	21✔
47
48	function getCurrentAssertContextVariable() {
49	assert(testStack.length, "Test stack should not be empty");	8✔
50
51	return testStack[testStack.length - 1].assertVar;	8✔
52	}
53
54	function isAssertEqual(calleeNode) {
55	return calleeNode &&	19✔
56	calleeNode.type === "MemberExpression" &&
57	calleeNode.property.type === "Identifier" &&
58	calleeNode.property.name === "equal" &&
59	calleeNode.object.type === "Identifier" &&
60	calleeNode.object.name === getCurrentAssertContextVariable();
61	}
62
63	function reportError(node, isGlobal) {
64	context.report({	6✔
65	node: node,
66	messageId: isGlobal ? "unexpectedGlobalEqual" : "unexpectedAssertEqual",	6✔
67	data: {
68	assertVar: isGlobal ? null : getCurrentAssertContextVariable()	6✔
69	},
70	suggest: [
71	{
72	messageId: "switchToDeepEqual",
73	fix(fixer) {
74	return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "deepEqual");	6✔
75	}
76	},
77	{
78	messageId: "switchToPropEqual",
79	fix(fixer) {
80	return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "propEqual");	6✔
81	}
82	},
83	{
84	messageId: "switchToStrictEqual",
85	fix(fixer) {
86	return fixer.replaceText(isGlobal ? node.callee : node.callee.property, "strictEqual");	6✔
87	}
88	}
89	]
90
91	});
92	}
93
94	return {	21✔
95	"CallExpression": function (node) {
96	/* istanbul ignore else: correctly does nothing */
97	if (utils.isTest(node.callee) \|\| utils.isAsyncTest(node.callee)) {	40✔
98	testStack.push({	20✔
99	assertVar: utils.getAssertContextNameForTest(node.arguments)
100	});
101	} else if (testStack.length > 0) {
102	if (isAssertEqual(node.callee)) {
103	reportError(node, false);
104	} else if (globalEqualCallNodes.has(node)) {
105	reportError(node, true);
106	}
107	}
108	},
109	"CallExpression:exit": function (node) {
110	/* istanbul ignore else: correctly does nothing */
111	if (utils.isTest(node.callee) \|\| utils.isAsyncTest(node.callee)) {	40✔
112	testStack.pop();	20✔
113	}
114	},
115	"Program": function () {
116	// Gather all calls to global `equal()`.
117
118	const tracker = new ReferenceTracker(context.getScope());	21✔
119	const traceMap = { equal: { [ReferenceTracker.CALL]: true } };	21✔
120
121	for (const { node } of tracker.iterateGlobalReferences(traceMap)) {	21✔
122	globalEqualCallNodes.add(node);	3✔
123	}
124	}
125	};
126	}
127	};

platinumazure / eslint-plugin-qunit / 4748569255

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous