[test] Introduce Platform.DevToolsPath.urlString helper.

This adds a helper function to avoid sprinkling casts to
`Platform.DevToolsPath.UrlString` all over our unit test
suite, combined with an ESLint rule to enforce that we
use this helper consistently.

This leads to much more readable test code for unit tests
that are concerned with APIs that take `UrlString`s, and
the code is more consistent.

Bug: 323797639
Change-Id: I6d797c0db9e5bd2fd019b83b9a7a269c7437ebdf
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6148578
Auto-Submit: Benedikt Meurer <[email protected]>
Commit-Queue: Benedikt Meurer <[email protected]>
Reviewed-by: Danil Somsikov <[email protected]>

Author: bmeurer

eslint.config.mjs

@@ -268,11 +268,11 @@ export default [
       parserOptions: {
         allowAutomaticSingleRunInference: true,
         project: join(
-          import.meta.dirname,
-          'config',
-          'typescript',
-          'tsconfig.eslint.json',
-        ),
+            import.meta.dirname,
+            'config',
+            'typescript',
+            'tsconfig.eslint.json',
+            ),
       },
     },
 
@@ -462,12 +462,12 @@ export default [
         {
           // Enforce that any import of models/trace/trace.js names the import Trace.
           modulePath: join(
-            import.meta.dirname,
-            'front_end',
-            'models',
-            'trace',
-            'trace.js',
-          ),
+              import.meta.dirname,
+              'front_end',
+              'models',
+              'trace',
+              'trace.js',
+              ),
           importName: 'Trace',
         },
       ],
@@ -579,6 +579,7 @@ export default [
       'rulesdir/prefer-assert-instance-of': 'error',
       'rulesdir/prefer-assert-is-ok': 'error',
       'rulesdir/prefer-assert-length-of': 'error',
+      'rulesdir/prefer-url-string': 'error',
       'rulesdir/trace-engine-test-timeouts': 'error',
     },
 

front_end/core/common/ParsedURL.test.ts

@@ -2,14 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import type * as Platform from '../platform/platform.js';
+import * as Platform from '../platform/platform.js';
 
 import * as Common from './common.js';
 
+const {urlString} = Platform.DevToolsPath;
 const ParsedURL = Common.ParsedURL.ParsedURL;
 
 function assertEqualUrlStringString(actual: Platform.DevToolsPath.UrlString|null, expected: string, message?: string) {
-  assert.strictEqual(actual, expected as Platform.DevToolsPath.UrlString, message);
+  assert.strictEqual(actual, urlString`${expected}`, message);
 }
 
 describe('Parsed URL', () => {
@@ -146,13 +147,13 @@ describe('Parsed URL', () => {
   });
 
   it('converts path that starts with "file://" to a platform path', () => {
-    const pathTest = 'file://usr/lib' as Platform.DevToolsPath.UrlString;
+    const pathTest = urlString`file://usr/lib`;
     const convertedPath = ParsedURL.urlToRawPathString(pathTest);
     assert.strictEqual(convertedPath, 'usr/lib', 'URL was not converted successfully');
   });
 
   it('converts path that starts with "file:///" to a platform path on Windows', () => {
-    const pathTest = 'file:///usr/lib' as Platform.DevToolsPath.UrlString;
+    const pathTest = urlString`file:///usr/lib`;
     const convertedPath = ParsedURL.urlToRawPathString(pathTest, true);
     assert.strictEqual(convertedPath, 'usr\\lib', 'URL was not converted successfully');
   });
@@ -191,26 +192,26 @@ describe('Parsed URL', () => {
   });
 
   it('extracts the path from a valid URL', () => {
-    const urlTest = 'http://www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`http://www.example.com/test/path`;
     const extractedPath = ParsedURL.extractPath(urlTest);
     assert.strictEqual(extractedPath, '/test/path', 'path extracted incorrectly');
   });
 
   it('returns an empty string as a path if the URL is not valid', () => {
-    const urlTest = 'www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`www.example.com/test/path`;
     const extractedPath = ParsedURL.extractPath(urlTest);
     assert.strictEqual(extractedPath, '', 'did not return an empty path');
   });
 
   it('extracts the origin from a valid URL', () => {
-    const urlTest = 'http://www.example.com/test/path' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`http://www.example.com/test/path`;
     const extractedOrigin = ParsedURL.extractOrigin(urlTest);
     assert.strictEqual(extractedOrigin, 'http://www.example.com', 'origin extracted incorrectly');
   });
 
   it('returns an empty string as a origin if the URL is not valid', () => {
     const urlTest = 'www.example.com/test/path';
-    const extractedOrigin = ParsedURL.extractOrigin(urlTest as Platform.DevToolsPath.UrlString);
+    const extractedOrigin = ParsedURL.extractOrigin(urlString`${urlTest}`);
     assert.strictEqual(extractedOrigin, '', 'did not return an empty path');
   });
 
@@ -270,28 +271,28 @@ describe('Parsed URL', () => {
 
   it('uses the completeURL function to return a data URL as it is', () => {
     const hrefTest = 'data:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a blob URL as it is', () => {
     const hrefTest = 'blob:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a javascript URL as it is', () => {
     const hrefTest = 'javascript:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return a mailto URL as it is', () => {
     const hrefTest = 'mailto:http://www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
@@ -347,7 +348,7 @@ describe('Parsed URL', () => {
 
     for (const {href, expected} of cases) {
       it(`can use completeURL to normalize "${href}"`, () => {
-        const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+        const baseUrlTest = urlString`www.example.com`;
         const completeUrl = ParsedURL.completeURL(baseUrlTest, href);
         assertEqualUrlStringString(completeUrl, expected, 'complete URL is not returned correctly');
       });
@@ -356,44 +357,44 @@ describe('Parsed URL', () => {
 
   it('uses the completeURL function to return null for invalid href and invalid base URL', () => {
     const hrefTest = 'www.example.com';
-    const baseUrlTest = 'www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assert.isNull(completeUrl, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return the href if the base URL is a data URL', () => {
     const hrefTest = 'www.example.com';
-    const baseUrlTest = 'data://www.example.com' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`data://www.example.com`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to return the href with scheme if the base URL was valid and the href scheme was dropped',
      () => {
        const hrefTest = '//www.example.com';
-       const baseUrlTest = 'http://www.example.com/' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(completeUrl, 'http:' + hrefTest, 'complete URL is not returned correctly');
      });
 
   it('uses the completeURL function to resolve an empty href to a base URL without fragment', () => {
     const hrefTest = '';
-    const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, baseUrlTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to resolve a fragment href to a base URL with fragment', () => {
     const hrefTest = '#testFragment';
-    const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+    const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
     const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
     assertEqualUrlStringString(completeUrl, baseUrlTest + hrefTest, 'complete URL is not returned correctly');
   });
 
   it('uses the completeURL function to resolve a parameters href to a base URL with the parameters from the href while the base URL has parameters',
      () => {
        const hrefTest = '?hrefParams=t';
-       const baseUrlTest = 'http://www.example.com/?testParam=t' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/?testParam=t`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(
            completeUrl, 'http://www.example.com/' + hrefTest, 'complete URL is not returned correctly');
@@ -402,7 +403,7 @@ describe('Parsed URL', () => {
   it('uses the completeURL function to resolve a parameters href to a base URL with the parameters from the href while the base URL does not have parameters',
      () => {
        const hrefTest = '?hrefParams=t';
-       const baseUrlTest = 'http://www.example.com/' as Platform.DevToolsPath.UrlString;
+       const baseUrlTest = urlString`http://www.example.com/`;
        const completeUrl = ParsedURL.completeURL(baseUrlTest, hrefTest);
        assertEqualUrlStringString(completeUrl, baseUrlTest + hrefTest, 'complete URL is not returned correctly');
      });
@@ -590,18 +591,15 @@ describe('Parsed URL', () => {
 
   it('returns the correct results for all ported web_tests unit tests', () => {
     assertEqualUrlStringString(
-        ParsedURL.completeURL(
-            'http://example.com/script.js' as Platform.DevToolsPath.UrlString, 'http://example.com/map.json'),
+        ParsedURL.completeURL(urlString`http://example.com/script.js`, 'http://example.com/map.json'),
         'http://example.com/map.json');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://example.com/script.js' as Platform.DevToolsPath.UrlString, '/map.json'),
-        'http://example.com/map.json');
+        ParsedURL.completeURL(urlString`http://example.com/script.js`, '/map.json'), 'http://example.com/map.json');
     assertEqualUrlStringString(
-        ParsedURL.completeURL(
-            'http://example.com/scripts/script.js' as Platform.DevToolsPath.UrlString, '../maps/map.json'),
+        ParsedURL.completeURL(urlString`http://example.com/scripts/script.js`, '../maps/map.json'),
         'http://example.com/maps/map.json');
 
-    const baseURL = 'http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString;
+    const baseURL = urlString`http://a/b/c/d;p?q`;
 
     assertEqualUrlStringString(ParsedURL.completeURL(baseURL, 'http://h'),
                                'http://h/');  // modified from RFC3986
@@ -626,13 +624,11 @@ describe('Parsed URL', () => {
     assertEqualUrlStringString(ParsedURL.completeURL(baseURL, 'g#s/../x'), 'http://a/b/c/g#s/../x');
 
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString, '//secure.com/moo'),
-        'http://secure.com/moo');
+        ParsedURL.completeURL(urlString`http://a/b/c/d;p?q`, '//secure.com/moo'), 'http://secure.com/moo');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://a/b/c/d;p?q' as Platform.DevToolsPath.UrlString, 'cat.jpeg'),
-        'http://a/b/c/cat.jpeg');
+        ParsedURL.completeURL(urlString`http://a/b/c/d;p?q`, 'cat.jpeg'), 'http://a/b/c/cat.jpeg');
     assertEqualUrlStringString(
-        ParsedURL.completeURL('http://example.com/path.css?query#fragment' as Platform.DevToolsPath.UrlString, ''),
+        ParsedURL.completeURL(urlString`http://example.com/path.css?query#fragment`, ''),
         'http://example.com/path.css?query');
   });
 
@@ -687,20 +683,20 @@ describe('Parsed URL', () => {
   });
 
   it('converts relative platform path and base URL to URL', () => {
-    const baseUrl = 'http://localhost:8080/my%20folder/old%20path' as Platform.DevToolsPath.UrlString;
+    const baseUrl = urlString`http://localhost:8080/my%20folder/old%20path`;
     const relativePath = 'new spaced%20name' as Platform.DevToolsPath.RawPathString;
     const convertedUrl = ParsedURL.relativePathToUrlString(relativePath, baseUrl);
     assert.strictEqual(convertedUrl, 'http://localhost:8080/my%20folder/new%20spaced%2520name');
   });
 
   it('converts URL to a platform path that includes drive letter and spaces on Windows', () => {
-    const urlTest = 'file:///C:/Program%20Files/Google' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`file:///C:/Program%20Files/Google`;
     const convertedUrl = ParsedURL.urlToRawPathString(urlTest, true);
     assert.strictEqual(convertedUrl, 'C:\\Program Files\\Google', 'URL was not converted successfully');
   });
 
   it('converts URL to a platform path that includes spaces and percents', () => {
-    const urlTest = 'file:///home/user/with%20space/with%2520escape' as Platform.DevToolsPath.UrlString;
+    const urlTest = urlString`file:///home/user/with%20space/with%2520escape`;
     const convertedUrl = ParsedURL.urlToRawPathString(urlTest, false);
     assert.strictEqual(convertedUrl, '/home/user/with space/with%20escape', 'URL was not converted successfully');
   });
@@ -715,8 +711,8 @@ describe('Parsed URL', () => {
   it('converts platform path with variety of special characters to URL and back consistently with Chrome', () => {
     const platformPathTest =
         '/home/a:b@c(d, e+f)=&g;#h$' as Platform.DevToolsPath.RawPathString;  // Valid filename on unix
-    const urlTest = 'file:///home/a:b@c(d,%20e+f)=&g%3B%23h$' as
-        Platform.DevToolsPath.UrlString;  // URL in Chrome address bar if you open that file
+    const urlTest =
+        urlString`file:///home/a:b@c(d,%20e+f)=&g%3B%23h\$`;  // URL in Chrome address bar if you open that file
     assert.strictEqual(ParsedURL.rawPathToUrlString(platformPathTest), urlTest);
     assert.strictEqual(ParsedURL.urlToRawPathString(urlTest), platformPathTest);
   });