chrome-devtools-frontend 1.0.945884 → 1.0.948295

package/scripts/build/rjsmin.py

@@ -119,8 +119,7 @@ def _make_jsmin(python_only=False):
     charclass = r'(?:\[[^\\\]\r\n]*(?:\\[^\r\n][^\\\]\r\n]*)*\])'
     nospecial = r'[^/\\\[\r\n]'
     regex = r'(?:/(?![\r\n/*])%s*(?:(?:\\[^\r\n]|%s)%s*)*/)' % (
-        nospecial, charclass, nospecial
-    )
+        nospecial, charclass, nospecial)
     space = r'(?:%s|%s)' % (space_chars, space_comment)
     newline = r'(?:%s?[\r\n])' % line_comment
 
@@ -147,36 +146,28 @@ def _make_jsmin(python_only=False):
                     first = last = char
             if last is not None:
                 result.append((first, last))
-            return ''.join(['%s%s%s' % (
-                chr(first),
-                last > first + 1 and '-' or '',
-                last != first and chr(last) or ''
-            ) for first, last in result])  # noqa
+            return ''.join([
+                '%s%s%s' % (chr(first), last > first + 1 and '-'
+                            or '', last != first and chr(last) or '')
+                for first, last in result
+            ])  # noqa
 
         return _re.sub(
             r'([\000-\040\047])',  # \047 for better portability
-            lambda m: '\\%03o' % ord(m.group(1)), (
-                sequentize(result)
-                .replace('\\', '\\\\')
-                .replace('[', '\\[')
-                .replace(']', '\\]')
-            )
-        )
+            lambda m: '\\%03o' % ord(m.group(1)),
+            (sequentize(result).replace('\\', '\\\\').replace(
+                '[', '\\[').replace(']', '\\]')))
 
     def id_literal_(what):
         """ Make id_literal like char class """
         match = _re.compile(what).match
-        result = ''.join([
-            chr(c) for c in xrange(127) if not match(chr(c))
-        ])
+        result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])
         return '[^%s]' % fix_charclass(result)
 
     def not_id_literal_(keep):
         """ Make negated id_literal like char class """
         match = _re.compile(id_literal_(keep)).match
-        result = ''.join([
-            chr(c) for c in xrange(127) if not match(chr(c))
-        ])
+        result = ''.join([chr(c) for c in xrange(127) if not match(chr(c))])
         return r'[%s]' % fix_charclass(result)
 
     not_id_literal = not_id_literal_(r'[a-zA-Z0-9_$]')
@@ -192,28 +183,26 @@ def _make_jsmin(python_only=False):
 
     space_sub_simple = _re.compile((
         # noqa pylint: disable = bad-continuation
-
-        r'(%(dull)s+)'                                         # 0
-        r'|(%(strings)s%(dull)s*)'                             # 1
+        r'(%(dull)s+)'  # 0
+        r'|(%(strings)s%(dull)s*)'  # 1
         r'|(?<=%(preregex1)s)'
-            r'%(space)s*(?:%(newline)s%(space)s*)*'
-            r'(%(regex)s)'                                     # 2
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 3
-                r'(?=%(post_regex_off)s))?'
+        r'%(space)s*(?:%(newline)s%(space)s*)*'
+        r'(%(regex)s)'  # 2
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 3
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)*'          # 4
-            r'(%(regex)s)'                                     # 5
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 6
-                r'(?=%(post_regex_off)s))?'
+        r'%(space)s*(?:(%(newline)s)%(space)s*)*'  # 4
+        r'(%(regex)s)'  # 5
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 6
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'%(space)s*(?:(%(newline)s)%(space)s*)+'          # 7
-            r'(?=%(id_literal_open)s)'
+        r'%(space)s*(?:(%(newline)s)%(space)s*)+'  # 7
+        r'(?=%(id_literal_open)s)'
         r'|(?<=%(id_literal)s)(%(space)s)+(?=%(id_literal)s)'  # 8
-        r'|(?<=\+)(%(space)s)+(?=\+)'                          # 9
-        r'|(?<=-)(%(space)s)+(?=-)'                            # 10
+        r'|(?<=\+)(%(space)s)+(?=\+)'  # 9
+        r'|(?<=-)(%(space)s)+(?=-)'  # 10
         r'|%(space)s+'
-        r'|(?:%(newline)s%(space)s*)+'
-    ) % locals()).sub
+        r'|(?:%(newline)s%(space)s*)+') % locals()).sub
 
     # print space_sub_simple.__self__.pattern
 
@@ -245,35 +234,33 @@ def _make_jsmin(python_only=False):
 
     space_sub_banged = _re.compile((
         # noqa pylint: disable = bad-continuation
-
-        r'(%(dull)s+)'                                         # 0
-        r'|(%(strings)s%(dull)s*)'                             # 1
+        r'(%(dull)s+)'  # 0
+        r'|(%(strings)s%(dull)s*)'  # 1
         r'|(?<=%(preregex1)s)'
-            r'(%(space)s*(?:%(newline)s%(space)s*)*)'          # 2
-            r'(%(regex)s)'                                     # 3
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 4
-                r'(?=%(post_regex_off)s))?'
+        r'(%(space)s*(?:%(newline)s%(space)s*)*)'  # 2
+        r'(%(regex)s)'  # 3
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 4
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(preregex2)s)'
-            r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'        # 5, 6
-            r'(%(regex)s)'                                     # 7
-            r'(%(space)s*(?:%(newline)s%(space)s*)+'           # 8
-                r'(?=%(post_regex_off)s))?'
+        r'(%(space)s*(?:(%(newline)s)%(space)s*)*)'  # 5, 6
+        r'(%(regex)s)'  # 7
+        r'(%(space)s*(?:%(newline)s%(space)s*)+'  # 8
+        r'(?=%(post_regex_off)s))?'
         r'|(?<=%(id_literal_close)s)'
-            r'(%(space)s*(?:%(newline)s%(space)s*)+)'          # 9
-            r'(?=%(id_literal_open)s)'
+        r'(%(space)s*(?:%(newline)s%(space)s*)+)'  # 9
+        r'(?=%(id_literal_open)s)'
         r'|(?<=%(id_literal)s)(%(space)s+)(?=%(id_literal)s)'  # 10
-        r'|(?<=\+)(%(space)s+)(?=\+)'                          # 11
-        r'|(?<=-)(%(space)s+)(?=-)'                            # 12
-        r'|(%(space)s+)'                                       # 13
-        r'|((?:%(newline)s%(space)s*)+)'                       # 14
+        r'|(?<=\+)(%(space)s+)(?=\+)'  # 11
+        r'|(?<=-)(%(space)s+)(?=-)'  # 12
+        r'|(%(space)s+)'  # 13
+        r'|((?:%(newline)s%(space)s*)+)'  # 14
     ) % locals()).sub
 
     # print space_sub_banged.__self__.pattern
 
-    keep = _re.compile((
-        r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'
-        r'|(%(bang_comment)s+)'
-    ) % locals()).sub
+    keep = _re.compile(
+        (r'%(space_chars)s+|%(space_comment_nobang)s+|%(newline)s+'
+         r'|(%(bang_comment)s+)') % locals()).sub
     keeper = lambda m: m.groups()[0] or ''
 
     # print keep.__self__.pattern
@@ -333,16 +320,15 @@ def _make_jsmin(python_only=False):
         # pylint: disable = redefined-outer-name
 
         if keep_bang_comments:
-            return space_sub_banged(
-                space_subber_banged, '\n%s\n' % script
-            ).strip()
+            return space_sub_banged(space_subber_banged,
+                                    '\n%s\n' % script).strip()
         else:
-            return space_sub_simple(
-                space_subber_simple, '\n%s\n' % script
-            ).strip()
+            return space_sub_simple(space_subber_simple,
+                                    '\n%s\n' % script).strip()
 
     return jsmin
 
+
 jsmin = _make_jsmin()
 
 
@@ -403,28 +389,19 @@ def jsmin_for_posers(script, keep_bang_comments=False):
             r'\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)))+(?=-)|(?:['
             r'\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/)'
             r')+|(?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014\016-\040]'
-            r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+'
-        )
+            r'|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+')
 
         def subber(match):
             """ Substitution callback """
             groups = match.groups()
-            return (
-                groups[0] or
-                groups[1] or
-                (groups[3] and (groups[2] + '\n')) or
-                groups[2] or
-                (groups[5] and "%s%s%s" % (
-                    groups[4] and '\n' or '',
-                    groups[5],
-                    groups[6] and '\n' or '',
-                )) or
-                (groups[7] and '\n') or
-                (groups[8] and ' ') or
-                (groups[9] and ' ') or
-                (groups[10] and ' ') or
-                ''
-            )
+            return (groups[0] or groups[1]
+                    or (groups[3] and (groups[2] + '\n')) or groups[2]
+                    or (groups[5] and "%s%s%s" % (
+                        groups[4] and '\n' or '',
+                        groups[5],
+                        groups[6] and '\n' or '',
+                    )) or (groups[7] and '\n') or (groups[8] and ' ')
+                    or (groups[9] and ' ') or (groups[10] and ' ') or '')
     else:
         rex = (
             r'([^\047"/\000-\040]+)|((?:(?:\047[^\047\\\r\n]*(?:\\(?:[^\r\n]'
@@ -457,46 +434,39 @@ def jsmin_for_posers(script, keep_bang_comments=False):
             r'11\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))+)(?=-'
             r')|((?:[\000-\011\013\014\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*'
             r'\*+)*/))+)|((?:(?:(?://[^\r\n]*)?[\r\n])(?:[\000-\011\013\014'
-            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)'
-        )
-
-        keep = _re.compile((
-            r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'
-            r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'
-            r'*]*\*+)*/)+)'
-        ) % locals()).sub
+            r'\016-\040]|(?:/\*[^*]*\*+(?:[^/*][^*]*\*+)*/))*)+)')
+
+        keep = _re.compile(
+            (r'[\000-\011\013\014\016-\040]+|(?:/\*(?!!)[^*]*\*+(?:[^/*][^*]*'
+             r'\*+)*/)+|(?:(?://[^\r\n]*)?[\r\n])+|((?:/\*![^*]*\*+(?:[^/*][^'
+             r'*]*\*+)*/)+)') % locals()).sub
         keeper = lambda m: m.groups()[0] or ''
 
         def subber(match):
             """ Substitution callback """
             groups = match.groups()
-            return (
-                groups[0] or
-                groups[1] or
-                (groups[3] and "%s%s%s%s" % (
-                    keep(keeper, groups[2]),
-                    groups[3],
-                    keep(keeper, groups[4] or ''),
-                    groups[4] and '\n' or '',
-                )) or
-                (groups[7] and "%s%s%s%s%s" % (
-                    keep(keeper, groups[5]),
-                    groups[6] and '\n' or '',
-                    groups[7],
-                    keep(keeper, groups[8] or ''),
-                    groups[8] and '\n' or '',
-                )) or
-                (groups[9] and keep(keeper, groups[9] + '\n')) or
-                (groups[10] and keep(keeper, groups[10]) or ' ') or
-                (groups[11] and keep(keeper, groups[11]) or ' ') or
-                (groups[12] and keep(keeper, groups[12]) or ' ') or
-                keep(keeper, groups[13] or groups[14])
-            )
+            return (groups[0] or groups[1] or (groups[3] and "%s%s%s%s" % (
+                keep(keeper, groups[2]),
+                groups[3],
+                keep(keeper, groups[4] or ''),
+                groups[4] and '\n' or '',
+            )) or (groups[7] and "%s%s%s%s%s" % (
+                keep(keeper, groups[5]),
+                groups[6] and '\n' or '',
+                groups[7],
+                keep(keeper, groups[8] or ''),
+                groups[8] and '\n' or '',
+            )) or (groups[9] and keep(keeper, groups[9] + '\n'))
+                    or (groups[10] and keep(keeper, groups[10]) or ' ')
+                    or (groups[11] and keep(keeper, groups[11]) or ' ')
+                    or (groups[12] and keep(keeper, groups[12]) or ' ')
+                    or keep(keeper, groups[13] or groups[14]))
 
     return _re.sub(rex, subber, '\n%s\n' % script).strip()
 
 
 if __name__ == '__main__':
+
     def main():
         """ Main """
         import sys as _sys
@@ -508,8 +478,7 @@ if __name__ == '__main__':
         else:
             xjsmin = jsmin
 
-        _sys.stdout.write(xjsmin(
-            _sys.stdin.read(), keep_bang_comments=keep_bang_comments
-        ))
+        _sys.stdout.write(
+            xjsmin(_sys.stdin.read(), keep_bang_comments=keep_bang_comments))
 
     main()

package/scripts/eslint_rules/lib/l10n_filename_matches.js

@@ -5,9 +5,6 @@
 'use strict';
 
 const path = require('path');
-const {devtoolsRootPath} = require('../../devtools_paths.js');
-
-const DEFAULT_FRONT_END_DIRECTORY = path.join(devtoolsRootPath(), 'front_end');
 
 function isModuleScope(context) {
   return context.getScope().type === 'module';
@@ -60,10 +57,13 @@ module.exports = {
           return;
         }
 
-        let frontEndDirectory = DEFAULT_FRONT_END_DIRECTORY;
+        let frontEndDirectory = '';
         if (context.options && context.options[0]?.rootFrontendDirectory) {
           frontEndDirectory = context.options[0].rootFrontendDirectory;
         }
+        if (!frontEndDirectory) {
+          throw new Error('rootFrontendDirectory must be provided.');
+        }
         const currentSourceFile = path.resolve(context.getFilename());
         const currentFileRelativeToFrontEnd = path.relative(frontEndDirectory, currentSourceFile);
 

package/scripts/eslint_rules/lib/lit_html_no_attribute_quotes.js

@@ -0,0 +1,101 @@
+// Copyright 2021 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';
+
+function isLitHtmlTemplateCall(taggedTemplateExpressionNode) {
+  // Match LitHtml.html``
+  const {tag} = taggedTemplateExpressionNode;
+  if (!tag) {
+    return false;
+  }
+  // Match LitHtml.html``
+  const isLitHtmlDotHtmlCall = tag.object?.name === 'LitHtml' && tag.property?.name === 'html';
+  // Match html`` (and guess that it's Lit)
+  const isDestructuredHtmlCall = tag.type === 'Identifier' && tag.name === 'html';
+
+  return isLitHtmlDotHtmlCall || isDestructuredHtmlCall;
+}
+
+function templateElementPartStartsWithDoubleQuote(templateElementPartNode) {
+  return templateElementPartNode.value.raw.startsWith('"');
+}
+function templateElementPartEndsWithEqualsDoubleQuote(templateElementPartNode) {
+  return templateElementPartNode.value.raw.endsWith('="');
+}
+
+function removeQuotesFromAttribute({fixer, firstPart, secondPart}) {
+  const [, rangeOfOpeningTemplatePartEnd] = firstPart.range;
+  // From the first part, we need to remove the last character, which is the double quote.
+  // We can do this by fetching the range of the node (range = start and end position on the line)
+  // However, for the template part with the opening quote, the range will also contain the ${ of the interpolation:
+  // <p class="${
+  // ^^^^^^^^^^^^ this is the text covered by the [start, end] range.
+  // So what we need to do is remove the quote, and leave the last two characters alone.
+  // Therefore we remove the third character back from the end, and only remove a single character, leaving the ${ part alone.
+  const startingQuoteRangeToRemove = [rangeOfOpeningTemplatePartEnd - 3, rangeOfOpeningTemplatePartEnd - 2];
+
+  const [rangeOfClosingTemplatePartStart] = secondPart.range;
+  // It's a similar story for the second part where the range includes the }:
+  // }">foo</p>
+  // ^^^^^^^^^^ this is the range
+  // So therefore we get the start of the range, and add one to it, to dodge the } character, and then remove only the quote.
+  const endingQuoteRangeToRemove = [rangeOfClosingTemplatePartStart + 1, rangeOfClosingTemplatePartStart + 2];
+
+  return [fixer.removeRange(startingQuoteRangeToRemove), fixer.removeRange(endingQuoteRangeToRemove)];
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+
+    docs: {
+      description: 'ensure no extra quotes around attributes when the value is interpolated',
+      category: 'Possible Errors',
+    },
+    fixable: 'code',
+    messages: {
+      attributeQuotesNotRequired:
+          'When interpolating a value as an attribute in LitHtml you do not need double quotes around it.',
+    },
+    schema: []  // no options
+  },
+  create: function(context) {
+    return {
+      TaggedTemplateExpression(node) {
+        if (!isLitHtmlTemplateCall(node)) {
+          return;
+        }
+
+        // quasis here = the static parts of a template expression
+        // expressions = the dynamic parts of a template expression
+        // For example, given: <p class="${foo}"> we will have:
+        // quasis: ['<p class="', '">']
+        // expressions: ['foo'] (it's actually an AST node representing ${foo})
+        // So what we do is walk through and look for quasi pairs where:
+        // 1. the first ends with ="
+        // 2. the second begins with "
+        // We can then be confident that we have found an attribute with quotes around it.
+        node.quasi.quasis.forEach((templateElement, index) => {
+          if (templateElementPartEndsWithEqualsDoubleQuote(templateElement)) {
+            const nextElement = node.quasi.quasis[index + 1];
+            if (nextElement && templateElementPartStartsWithDoubleQuote(nextElement)) {
+              const expressionBetweenTheParts = node.quasi.expressions[index];
+              context.report({
+                node: expressionBetweenTheParts,
+                messageId: 'attributeQuotesNotRequired',
+                fix(fixer) {
+                  return removeQuotesFromAttribute({
+                    fixer,
+                    firstPart: templateElement,
+                    secondPart: nextElement,
+                  });
+                }
+              });
+            }
+          }
+        });
+      },
+    };
+  }
+};

package/scripts/eslint_rules/lib/no_only_eslint_tests.js

@@ -0,0 +1,53 @@
+// Copyright 2021 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.
+
+module.exports = {
+  meta: {
+    type: 'problem',
+
+    docs: {
+      description: 'Usage of only: true in ESLint tests',
+      category: 'Possible Errors',
+    },
+    fixable: 'code',
+    messages: {noOnlyInESLintTest: 'You cannot use only: true in an ESLint test.'},
+    schema: []  // no options
+  },
+  create: function(context) {
+    function checkForOnlyInTestCases(testCaseObjects) {
+      for (const testCase of testCaseObjects) {
+        const onlyKeyProp = testCase.properties.find(prop => {
+          return prop.key.name === 'only';
+        });
+        if (onlyKeyProp) {
+          context.report({
+            node: onlyKeyProp,
+            messageId: 'noOnlyInESLintTest'
+
+          });
+        }
+      }
+    }
+
+    return {
+      // match ruleTester.run('foo', rule, {...})
+      'CallExpression[callee.object.name=\'ruleTester\'][callee.property.name=\'run\']'(node) {
+        // first argument = string name
+        // second argument = rule itself
+        // third argument = the object containing the test cases - what we want!
+        const tests = node.arguments[2];
+        if (!tests) {
+          return;
+        }
+
+        for (const testProperty of tests.properties) {
+          // Iterate over the "valid" and "invalid" rules
+          // Here .value = the array of test cases, and .elements gets us each
+          // object (individual test case) within that array.
+          checkForOnlyInTestCases(testProperty.value.elements);
+        }
+      }
+    };
+  }
+};

package/scripts/eslint_rules/tests/.eslintrc.js

@@ -0,0 +1,14 @@
+// Copyright 2021 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.
+
+const path = require('path');
+const rulesDirPlugin = require('eslint-plugin-rulesdir');
+
+rulesDirPlugin.RULES_DIR = path.join(__dirname, '..', 'lib');
+
+module.exports = {
+  'rules': {
+    'rulesdir/no_only_eslint_tests': 2,
+  }
+};

package/scripts/eslint_rules/tests/l10n_filename_matches_test.js

@@ -17,14 +17,17 @@ ruleTester.run('l10n_filename_matches', rule, {
     {
       code: 'const str_ = i18n.i18n.registerUIStrings(\'components/test.ts\', UIStrings);',
       filename: 'front_end/components/test.ts',
+      options: [{rootFrontendDirectory: path.join(__dirname, '..', '..', '..', 'front_end')}]
     },
     {
       code: 'const str_ = i18n.i18n.registerUIStrings(\'components/ModuleUIStrings.js\', UIStrings);',
       filename: 'front_end/components/test.ts',
+      options: [{rootFrontendDirectory: path.join(__dirname, '..', '..', '..', 'front_end')}]
     },
     {
       code: 'const str_ = i18n.i18n.registerUIStrings(\'components/ModuleUIStrings.ts\', UIStrings);',
       filename: 'front_end/components/test.ts',
+      options: [{rootFrontendDirectory: path.join(__dirname, '..', '..', '..', 'front_end')}]
     },
     {
       code: 'const str_ = i18n.i18n.registerUIStrings(\'ModuleUIStrings.ts\', UIStrings);',
@@ -41,6 +44,7 @@ ruleTester.run('l10n_filename_matches', rule, {
     {
       code: 'const str_ = i18n.i18n.registerUIStrings(\'components/foo.ts\', UIStrings);',
       filename: 'front_end/components/test.ts',
+      options: [{rootFrontendDirectory: path.join(__dirname, '..', '..', '..', 'front_end')}],
       errors: [{
         message:
             'First argument to \'registerUIStrings\' call must be \'components/test.ts\' or the ModuleUIStrings.(js|ts)'

package/scripts/eslint_rules/tests/lit_html_no_attribute_quotes_test.js

@@ -0,0 +1,45 @@
+// Copyright 2021 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/lit_html_no_attribute_quotes.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+  parser: require.resolve('@typescript-eslint/parser'),
+});
+
+ruleTester.run('lit_html_no_attribute_quotes', rule, {
+  valid: [
+    {
+      code: 'LitHtml.html`<p class=${foo}>foo</p>`',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'LitHtml.html`<p class=${foo}>"${someOutput}"</p>`',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'html`<p class=${foo}>"${someOutput}"</p>`',
+      filename: 'front_end/components/datagrid.ts',
+    },
+    {
+      code: 'html`<p class="my-${fooClassName}">"${someOutput}"</p>`',
+      filename: 'front_end/components/datagrid.ts',
+    },
+  ],
+  invalid: [
+    {
+      code: 'LitHtml.html`<p class="${foo}">foo</p>`',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'attributeQuotesNotRequired', column: 26, line: 1}],
+      output: 'LitHtml.html`<p class=${foo}>foo</p>`',
+    },
+    {
+      code: 'html`<p class="${foo}">foo</p>`',
+      filename: 'front_end/components/datagrid.ts',
+      errors: [{messageId: 'attributeQuotesNotRequired'}],
+      output: 'html`<p class=${foo}>foo</p>`',
+    },
+  ]
+});

package/scripts/eslint_rules/tests/no_only_eslint_tests_test.js

@@ -0,0 +1,94 @@
+// Copyright 2021 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.
+
+const rule = require('../lib/no_only_eslint_tests.js');
+const ruleTester = new (require('eslint').RuleTester)({
+  parserOptions: {ecmaVersion: 9, sourceType: 'module'},
+});
+
+ruleTester.run('no_only_eslint_tests', rule, {
+  valid: [
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        valid: [{
+          code: 'foo',
+          filename: 'foo.ts',
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+    },
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        invalid: [{
+          code: 'foo',
+          filename: 'foo.ts',
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+    },
+  ],
+
+  invalid: [
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        valid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+      errors: [{messageId: 'noOnlyInESLintTest'}],
+    },
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        invalid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+          errors: [{ messagId: 'foo' }]
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+      errors: [{messageId: 'noOnlyInESLintTest'}],
+    },
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        valid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+        }],
+        invalid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+          errors: [{ messagId: 'foo' }]
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+      errors: [{messageId: 'noOnlyInESLintTest'}, {messageId: 'noOnlyInESLintTest'}],
+    },
+    {
+      code: `ruleTester.run('my_eslint_rule', rule, {
+        valid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+        }, {
+          code: 'foo',
+          filename: 'foo.ts',
+        }],
+        invalid: [{
+          only: true,
+          code: 'foo',
+          filename: 'foo.ts',
+          errors: [{ messagId: 'foo' }]
+        }]
+      })`,
+      filename: 'scripts/eslint_rules/tests/foo_test.js',
+      errors: [{messageId: 'noOnlyInESLintTest'}, {messageId: 'noOnlyInESLintTest'}],
+    },
+  ]
+});