test(linter): Regenerate tests for various Unicorn rules

crates/oxc_linter/src/rules/unicorn/consistent_assert.rs

@@ -138,82 +138,82 @@ fn test() {
         "assert(foo)",
         r#"import assert from "assert";"#,
         "import assert from 'node:assert';
-			assert;",
+            assert;",
         "import customAssert from 'node:assert';
-			assert(foo);",
+            assert(foo);",
         "function foo (assert) {
-				assert(bar);
-			}",
+                assert(bar);
+            }",
         "import assert from 'node:assert';
-			function foo (assert) {
-				assert(bar);
-			}",
+            function foo (assert) {
+                assert(bar);
+            }",
         "import {strict} from 'node:assert/strict';
-			strict(foo);",
+            strict(foo);",
         "import * as assert from 'node:assert';
-			assert(foo);",
+            assert(foo);",
         "export * as assert from 'node:assert';
-			assert(foo);",
+            assert(foo);",
         "export {default as assert} from 'node:assert';
-			export {assert as strict} from 'node:assert';
-			assert(foo);",
+            export {assert as strict} from 'node:assert';
+            assert(foo);",
         "import assert from 'node:assert/strict';
-			console.log(assert)",
+            console.log(assert)",
     ];
 
     let fail = vec![
         "import assert from 'assert';
-        	assert(foo)",
+            assert(foo)",
         "import assert from 'node:assert';
-        	assert(foo)",
+            assert(foo)",
         "import assert from 'assert/strict';
-        	assert(foo)",
+            assert(foo)",
         "import assert from 'node:assert/strict';
-        	assert(foo)",
+            assert(foo)",
         "import customAssert from 'assert';
-        	customAssert(foo)",
+            customAssert(foo)",
         "import customAssert from 'node:assert';
-        	customAssert(foo)",
+            customAssert(foo)",
         "import assert from 'assert';
-        	assert(foo)
-        	assert(bar)
-        	assert(baz)",
+            assert(foo)
+            assert(bar)
+            assert(baz)",
         "import {strict} from 'assert';
-        	strict(foo)",
+            strict(foo)",
         "import {strict as assert} from 'assert';
-        	assert(foo)",
+            assert(foo)",
         "import a, {strict as b, default as c} from 'node:assert';
-        	import d, {strict as e, default as f} from 'assert';
-        	import g, {default as h} from 'node:assert/strict';
-        	import i, {default as j} from 'assert/strict';
-        	a(foo);
-        	b(foo);
-        	c(foo);
-        	d(foo);
-        	e(foo);
-        	f(foo);
-        	g(foo);
-        	h(foo);
-        	i(foo);
-        	j(foo);",
+            import d, {strict as e, default as f} from 'assert';
+            import g, {default as h} from 'node:assert/strict';
+            import i, {default as j} from 'assert/strict';
+            a(foo);
+            b(foo);
+            c(foo);
+            d(foo);
+            e(foo);
+            f(foo);
+            g(foo);
+            h(foo);
+            i(foo);
+            j(foo);",
         "import assert from 'node:assert';
-        	assert?.(foo)",
+            assert?.(foo)",
         "import assert from 'assert';
-			((
-				/* comment */ ((
-					/* comment */
-					assert
-					/* comment */
-					)) /* comment */
-					(/* comment */ typeof foo === 'string', 'foo must be a string' /** after comment */)
-			));",
+            ((
+                /* comment */ ((
+                    /* comment */
+                    assert
+                    /* comment */
+                    )) /* comment */
+                    (/* comment */ typeof foo === 'string', 'foo must be a string' /** after comment */)
+            ));",
     ];
 
     let fix = vec![(
         "import assert from 'assert';
-			assert(foo)",
+            assert(foo)",
         "import assert from 'assert';
-			assert.ok(foo)",
+            assert.ok(foo)",
     ), (
         "import assert from 'node:assert';
             assert(foo)",

crates/oxc_linter/src/rules/unicorn/no_array_sort.rs

@@ -139,10 +139,10 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-        ("sorted = [...array].toSorted()", None),
-        ("sorted = array.toSorted()", None),
-        ("sorted = [...array].sort", None),
-        ("sorted = [...array].sort?.()", None),
+        ("sorted =[...array].toSorted()", None),
+        ("sorted =array.toSorted()", None),
+        ("sorted =[...array].sort", None),
+        ("sorted =[...array].sort?.()", None),
         ("array.sort()", None),
         ("array.sort?.()", None),
         ("array?.sort()", None),
@@ -152,6 +152,20 @@ fn test() {
         ("sorted = array.sort(compareFn, extraArgument)", None),
         (r#"import { Chunk } from "effect"; const sorted = Chunk.sort(compareFn)"#, None),
         (r#"import { Chunk as C } from "effect"; const sorted = C.sort(compareFn)"#, None),
+        // TODO: Get these passing?
+        // ("sorted = collection.sort({field: 1})", None),
+        // (r#"sorted = query.sort("field")"#, None),
+        // ("sorted = query.sort(1)", None),
+        // ("sorted = query.sort(-1)", None),
+        // ("sorted = query.sort(+1)", None),
+        // ("sorted = query.sort(`field`)", None),
+        // ("sorted = query.sort([criteria])", None),
+        // ("const docs = collection.find({id}).sort({expireAt: -1}).limit(1).toArray()", None),
+        // ("[...array].sort({field: 1})", None),
+        // (
+        //     "collection.sort({field: 1})",
+        //     Some(serde_json::json!([{ "allowExpressionStatement": false }])),
+        // ),
     ];
 
     let fail = vec![

crates/oxc_linter/src/rules/unicorn/prefer_add_event_listener.rs

@@ -285,38 +285,161 @@ fn test() {
     use crate::tester::Tester;
 
     let pass = vec![
-        "foo.addEventListener('click', () => {})",
-        "foo.removeEventListener('click', onClick)",
-        "foo.onclick",
-        "foo[onclick] = () => {}",
-        r#"foo["onclick"] = () => {}"#,
-        "foo.onunknown = () => {}",
-        "foo.setCallBack = () => {console.log('foo')}",
-        "setCallBack = () => {console.log('foo')}",
-        "foo.onclick.bar = () => {}",
-        "foo['x'] = true;",
+        ("foo.addEventListener('click', () => {})", None),
+        ("foo.removeEventListener('click', onClick)", None),
+        ("foo.onclick", None),
+        ("foo[onclick] = () => {}", None),
+        (r#"foo["onclick"] = () => {}"#, None),
+        ("foo.onunknown = () => {}", None),
+        ("foo.setCallBack = () => {console.log('foo')}", None),
+        ("setCallBack = () => {console.log('foo')}", None),
+        ("foo.onclick.bar = () => {}", None),
+        ("foo['x'] = true;", None),
+        // TODO: Uncomment these tests after we introduce support for the excludedPackages option.
+        // https://github.com/sindresorhus/eslint-plugin-unicorn/blob/0bf85e0df741255ac2d347eefc57daf4362ff0a0/docs/rules/prefer-add-event-listener.md#excludedpackages
+        // (
+        //     "const Koa = require('koa');
+        //     const app = new Koa();
+        //     app.onerror = () => {};",
+        //     None,
+        // ),
+        // (
+        //     "const sax = require('sax');
+        //     const parser = sax.parser();
+        //     parser.onerror = () => {};",
+        //     None,
+        // ),
+        // (
+        //     "import Koa from 'koa';
+        //     const app = new Koa();
+        //     app.onerror = () => {};",
+        //     None,
+        // ),
+        // (
+        //     "import sax from 'sax';
+        //     const parser = sax.parser();
+        //     parser.onerror = () => {};",
+        //     None,
+        // ),
+        // (
+        //     "import {sax as foo} from 'sax';
+        //     const parser = foo.parser();
+        //     parser.onerror = () => {};",
+        //     None,
+        // ),
+        // (
+        //     "const foo = require('foo');
+        //     foo.onerror = () => {};",
+        //     Some(serde_json::json!(excludeFooOptions)),
+        // ),
+        // (
+        //     "import foo from 'foo';
+        //     foo.onclick = () => {};",
+        //     Some(serde_json::json!(excludeFooOptions)),
+        // ),
     ];
 
     let fail = vec![
-        "foo.onclick = () => {}",
-        "foo.onclick = 1",
-        "foo.bar.onclick = onClick",
-        "const bar = null; foo.onclick = bar;",
-        "foo.onkeydown = () => {}",
-        "foo.ondragend = () => {}",
-        "foo.onclick = null",
-        "foo.onclick = undefined",
-        "window.onbeforeunload = null",
-        "window.onbeforeunload = undefined",
-        "window.onbeforeunload = foo",
-        "window.onbeforeunload = () => 'foo'",
-        "myWorker.port.onmessage = function(e) {}",
-        "((foo)).onclick = ((0, listener))",
-        "window.onload = window.onunload = function() {};",
-        "window.onunload ??= function() {};",
-        "window.onunload ||= function() {};",
-        "window.onunload += function() {};",
-        "(el as HTMLElement).onmouseenter = onAnchorMouseEnter;",
+        ("foo.onclick = () => {}", None),
+        ("foo.onclick = 1", None),
+        ("foo.bar.onclick = onClick", None),
+        ("const bar = null; foo.onclick = bar;", None),
+        ("foo.onkeydown = () => {}", None),
+        ("foo.ondragend = () => {}", None),
+        (
+            "foo.onclick = function (e) {
+                console.log(e);
+            }",
+            None,
+        ),
+        ("foo.onclick = null", None),
+        ("foo.onclick = undefined", None),
+        ("window.onbeforeunload = null", None),
+        ("window.onbeforeunload = undefined", None),
+        ("window.onbeforeunload = foo", None),
+        ("window.onbeforeunload = () => 'foo'", None),
+        (
+            "window.onbeforeunload = () => {
+                return bar;
+            }",
+            None,
+        ),
+        (
+            "window.onbeforeunload = function () {
+                return 'bar';
+            }",
+            None,
+        ),
+        (
+            "window.onbeforeunload = function () {
+                return;
+            }",
+            None,
+        ),
+        (
+            "window.onbeforeunload = function () {
+                (() => {
+                    return 'foo';
+                })();
+            }",
+            None,
+        ),
+        (
+            "window.onbeforeunload = e => {
+                console.log(e);
+            }",
+            None,
+        ),
+        (
+            "const foo = require('foo');
+            foo.onerror = () => {};",
+            None,
+        ),
+        (
+            "import foo from 'foo';
+            foo.onerror = () => {};",
+            None,
+        ),
+        (
+            "foo.onerror = () => {};
+            function bar() {
+                const koa = require('koa');
+                koa.onerror = () => {};
+            }",
+            None,
+        ),
+        // (
+        //     "const Koa = require('koa');
+        //     const app = new Koa();
+        //     app.onerror = () => {};",
+        //     Some(serde_json::json!(excludeFooOptions)),
+        // ),
+        // (
+        //     "import {Koa as Foo} from 'koa';
+        //     const app = new Foo();
+        //     app.onerror = () => {};",
+        //     Some(serde_json::json!(excludeFooOptions)),
+        // ),
+        // (
+        //     "const sax = require('sax');
+        //     const parser = sax.parser();
+        //     parser.onerror = () => {};",
+        //     Some(serde_json::json!(excludeFooOptions)),
+        // ),
+        ("myWorker.port.onmessage = function(e) {}", None),
+        ("((foo)).onclick = ((0, listener))", None),
+        ("window.onload = window.onunload = function() {};", None),
+        ("window.onunload ??= function() {};", None),
+        ("window.onunload ||= function() {};", None),
+        ("window.onunload += function() {};", None),
+        ("foo.onclick = true", None),
+        ("foo.onclick = 'bar'", None),
+        ("foo.onclick = `bar`", None),
+        ("foo.onclick = {}", None),
+        ("foo.onclick = []", None),
+        ("foo.onclick = void 0", None),
+        ("foo.onclick = new Handler()", None),
+        ("(el as HTMLElement).onmouseenter = onAnchorMouseEnter;", None),
     ];
 
     // TODO: Implement autofix and use these tests.