chrome-devtools-frontend 1.0.1386602 → 1.0.1402249

package/scripts/eslint_rules/tests/prefer-assert-instance-of.test.js

@@ -0,0 +1,197 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+const rule = require('../lib/prefer-assert-instance-of.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+});
+
+ruleTester.run('prefer-assert-instance-of', rule, {
+  valid: [
+    {
+      code: 'assert(a);',
+    },
+    {
+      code: 'assert(a, "message");',
+    },
+    {
+      code: 'assert.instanceOf(foo, Foo);',
+    },
+    {
+      code: 'assert.instanceOf(foo, Foo, "message");',
+    },
+    {
+      code: 'assert.notInstanceOf(foo, Foo);',
+    },
+    {
+      code: 'assert.notInstanceOf(foo, Foo, "message");',
+    },
+  ],
+
+  invalid: [
+    {
+      code: 'assert(foo instanceof Foo);',
+      output: 'assert.instanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert(foo instanceof Foo, "message");',
+      output: 'assert.instanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotFalse(foo instanceof Foo);',
+      output: 'assert.instanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotFalse(foo instanceof Foo, "message");',
+      output: 'assert.instanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isOk(foo instanceof Foo);',
+      output: 'assert.instanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isOk(foo instanceof Foo, "message");',
+      output: 'assert.instanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isTrue(foo instanceof Foo);',
+      output: 'assert.instanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isTrue(foo instanceof Foo, "message");',
+      output: 'assert.instanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.ok(foo instanceof Foo);',
+      output: 'assert.instanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.ok(foo instanceof Foo, "message");',
+      output: 'assert.instanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isFalse(foo instanceof Foo);',
+      output: 'assert.notInstanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isFalse(foo instanceof Foo, "message");',
+      output: 'assert.notInstanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotOk(foo instanceof Foo);',
+      output: 'assert.notInstanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotOk(foo instanceof Foo, "message");',
+      output: 'assert.notInstanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotTrue(foo instanceof Foo);',
+      output: 'assert.notInstanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.isNotTrue(foo instanceof Foo, "message");',
+      output: 'assert.notInstanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.notOk(foo instanceof Foo);',
+      output: 'assert.notInstanceOf(foo, Foo);',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.notOk(foo instanceof Foo, "message");',
+      output: 'assert.notInstanceOf(foo, Foo, "message");',
+      errors: [
+        {
+          messageId: 'useAssertNotInstanceOf',
+        },
+      ],
+    },
+  ],
+});

package/scripts/eslint_rules/tests/prefer-assert-is-ok.test.js

@@ -0,0 +1,81 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+const rule = require('../lib/prefer-assert-is-ok.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+});
+
+ruleTester.run('prefer-assert-is-ok', rule, {
+  valid: [
+    {
+      code: 'assert(a);',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'assert(a, "message");',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'assert.isOk(a);',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'assert.isOk(a, "message");',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'assert.isNotOk(a);',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'assert.isNotOk(a, "message");',
+      filename: 'foo.ts',
+    },
+  ],
+
+  invalid: [
+    {
+      code: 'assert.ok(foo);',
+      output: 'assert.isOk(foo);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertIsOk',
+        },
+      ],
+    },
+    {
+      code: 'assert.ok(foo, "message");',
+      output: 'assert.isOk(foo, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertIsOk',
+        },
+      ],
+    },
+    {
+      code: 'assert.notOk(foo);',
+      output: 'assert.isNotOk(foo);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertIsNotOk',
+        },
+      ],
+    },
+    {
+      code: 'assert.notOk(foo, "message");',
+      output: 'assert.isNotOk(foo, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertIsNotOk',
+        },
+      ],
+    },
+  ],
+});

package/scripts/eslint_rules/tests/prefer-assert-length-of.test.js

@@ -0,0 +1,145 @@
+// Copyright 2024 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+'use strict';
+
+const rule = require('../lib/prefer-assert-length-of.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+});
+
+ruleTester.run('prefer-assert-length-of', rule, {
+  valid: [
+    {
+      code: 'assert.strictEqual(a.length + b.length, 4);',
+      filename: 'foo.ts',
+    },
+    {
+      code: 'bar.deepEqual(weirdObject.length, [1, 2]);',
+      filename: 'foo.ts',
+    },
+  ],
+
+  invalid: [
+    {
+      code: 'assert.strictEqual(array.length, 1);',
+      output: 'assert.lengthOf(array, 1);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.strictEqual(20, array.length);',
+      output: 'assert.lengthOf(array, 20);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.strictEqual(array.length, 5, "message");',
+      output: 'assert.lengthOf(array, 5, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.strictEqual(9, array.length, "message");',
+      output: 'assert.lengthOf(array, 9, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.deepEqual(array.length, 1);',
+      output: 'assert.lengthOf(array, 1);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.deepEqual(20, array.length);',
+      output: 'assert.lengthOf(array, 20);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.deepEqual(array.length, 5, "message");',
+      output: 'assert.lengthOf(array, 5, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.deepEqual(9, array.length, "message");',
+      output: 'assert.lengthOf(array, 9, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.equal(array.length, 1);',
+      output: 'assert.lengthOf(array, 1);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.equal(20, array.length);',
+      output: 'assert.lengthOf(array, 20);',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.equal(array.length, 5, "message");',
+      output: 'assert.lengthOf(array, 5, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+    {
+      code: 'assert.equal(9, array.length, "message");',
+      output: 'assert.lengthOf(array, 9, "message");',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useAssertLengthOf',
+        },
+      ],
+    },
+  ],
+});

package/scripts/eslint_rules/tests/{use_private_class_members_test.js → prefer-private-class-members.test.js}

@@ -3,13 +3,13 @@
 // found in the LICENSE file.
 'use strict';
 
-const rule = require('../lib/use_private_class_members.js');
+const rule = require('../lib/prefer-private-class-members.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parser: require.resolve('@typescript-eslint/parser'),
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
 });
 
-ruleTester.run('use_private_class_members', rule, {
+ruleTester.run('prefer-private-class-members', rule, {
   valid: [
     {
       code: `class Foo {

package/scripts/eslint_rules/tests/{prefer_readonly_keyword_test.js → prefer-readonly-keyword.test.js}

@@ -3,19 +3,17 @@
 // found in the LICENSE file.
 'use strict';
 
-const rule = require('../lib/prefer_readonly_keyword.js');
+const rule = require('../lib/prefer-readonly-keyword.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
   parser: require.resolve('@typescript-eslint/parser'),
 });
 
-ruleTester.run('prefer_readonly_keyword', rule, {
+ruleTester.run('prefer-readonly-keyword', rule, {
   valid: [
     {
       filename: 'foo.ts',
-      code: `class X {
-        private foo: readonly string[];
-      }`,
+      code: 'class Foo { private foo: readonly string[]; }',
     },
     {
       filename: 'foo.ts',
@@ -29,26 +27,44 @@ ruleTester.run('prefer_readonly_keyword', rule, {
 
   invalid: [
     {
+      code: 'class Foo { private foo: ReadonlyArray<string>; }',
+      output: 'class Foo { private foo: readonly string[]; }',
       filename: 'foo.ts',
-      code: `class X {
-        private foo: ReadonlyArray<string>;
-      }`,
-      errors: [{message: 'Prefer the readonly keyword over the ReadonlyArray type.'}]
+      errors: [
+        {
+          messageId: 'useReadonlyKeyword',
+        },
+      ]
     },
     {
-      filename: 'foo.ts',
       code: 'function x(foo: ReadonlyArray<string>) {}',
-      errors: [{message: 'Prefer the readonly keyword over the ReadonlyArray type.'}]
+      output: 'function x(foo: readonly string[]) {}',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useReadonlyKeyword',
+        },
+      ]
     },
     {
-      filename: 'foo.ts',
       code: 'function x(foo: readonly string[]): ReadonlyArray<string> {}',
-      errors: [{message: 'Prefer the readonly keyword over the ReadonlyArray type.'}]
+      output: 'function x(foo: readonly string[]): readonly string[] {}',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useReadonlyKeyword',
+        },
+      ]
     },
     {
-      filename: 'foo.ts',
       code: 'const x: ReadonlyArray<string> = []',
-      errors: [{message: 'Prefer the readonly keyword over the ReadonlyArray type.'}]
+      output: 'const x: readonly string[] = []',
+      filename: 'foo.ts',
+      errors: [
+        {
+          messageId: 'useReadonlyKeyword',
+        },
+      ]
     },
   ]
 });

package/scripts/eslint_rules/tests/{screenshot_assertion_in_it_screenshot_test.js → screenshot-assertion-in-it-screenshot.test.js}

@@ -4,13 +4,13 @@
 
 'use strict';
 
-const rule = require('../lib/screenshot_assertion_in_it_screenshot.js');
+const rule = require('../lib/screenshot-assertion-in-it-screenshot.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
   parser: require.resolve('@typescript-eslint/parser'),
 });
 
-ruleTester.run('screenshot_assertion_in_it_screenshot', rule, {
+ruleTester.run('screenshot-assertion-in-it-screenshot', rule, {
   valid: [
     {
       code: `itScreenshot('does a thing', () => {

package/scripts/eslint_rules/tests/{set_data_type_reference_test.js → set-data-type-reference.test.js}

@@ -3,13 +3,13 @@
 // found in the LICENSE file.
 'use strict';
 
-const rule = require('../lib/set_data_type_reference.js');
+const rule = require('../lib/set-data-type-reference.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
   parser: require.resolve('@typescript-eslint/parser'),
 });
 
-ruleTester.run('set_data_type_reference', rule, {
+ruleTester.run('set-data-type-reference', rule, {
   valid: [
     {
       code: `class Foo extends HTMLElement {

package/scripts/eslint_rules/tests/{single_screenshot_assertion_per_test_test.js → single-screenshot-assertion-per-test.test.js}

@@ -4,13 +4,13 @@
 
 'use strict';
 
-const rule = require('../lib/single_screenshot_assertion_per_test.js');
+const rule = require('../lib/single-screenshot-assertion-per-test.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
   parser: require.resolve('@typescript-eslint/parser'),
 });
 
-ruleTester.run('single_screenshot_assertion_per_test', rule, {
+ruleTester.run('single-screenshot-assertion-per-test', rule, {
   valid: [
     {
       code: `it('does a thing', () => {

package/scripts/eslint_rules/tests/{static_custom_event_names_test.js → static-custom-event-names.test.js}

@@ -3,13 +3,13 @@
 // found in the LICENSE file.
 'use strict';
 
-const rule = require('../lib/static_custom_event_names.js');
+const rule = require('../lib/static-custom-event-names.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
   parser: require.resolve('@typescript-eslint/parser'),
 });
 
-ruleTester.run('static_custom_event_names', rule, {
+ruleTester.run('static-custom-event-names', rule, {
   valid: [
     {
       code: `class FooEvent extends Event {

package/scripts/eslint_rules/tests/{trace_engine_test_timeouts_test.js → trace-engine-test-timeouts.test.js}

@@ -3,12 +3,12 @@
 // found in the LICENSE file.
 'use strict';
 
-const rule = require('../lib/trace_engine_test_timeouts.js');
+const rule = require('../lib/trace-engine-test-timeouts.js');
 const ruleTester = new (require('eslint').RuleTester)({
   parserOptions: {ecmaVersion: 9, sourceType: 'module'},
 });
 
-ruleTester.run('trace_engine_test_timeouts', rule, {
+ruleTester.run('trace-engine-test-timeouts', rule, {
   valid: [
     {
       code: `it('does something', async function() {

package/scripts/generate_metric_compare_strings.js

@@ -60,7 +60,7 @@ for (const [localRating, localRatingText] of Object.entries(ratings)) {
     const tag = camelize(localRating) + capitalizeFirstLetter(camelize(fieldRating)) + 'DetailedCompare';
     const transition = localRating === fieldRating ? 'Additionally' : 'However';
     console.log(`  /**
-   * @description Text block that compares a local metric value to real user experiences. "field data" refers to performance data collected from real users on the site. "local" refers to a developers local testing environment.
+   * @description Text block that compares a local metric value to real user experiences. "field data" should be interpreted as "real user data". "local" refers to a developers local testing environment.
    * @example {LCP} PH1
    * @example {500 ms} PH2
    * @example {400 ms} PH3