core(lightwallet): add path to budget.json

lighthouse-cli/test/smokehouse/perf/perf-config.js

@@ -14,6 +14,7 @@ const perfConfig = {
 
     // A mixture of under, over, and meeting budget to exercise all paths.
     budgets: [{
+      path: '/',
       resourceCounts: [
         {resourceType: 'total', budget: 8},
         {resourceType: 'stylesheet', budget: 1}, // meets budget

lighthouse-core/audits/performance-budget.js

@@ -7,6 +7,8 @@
 
 const Audit = require('./audit.js');
 const ResourceSummary = require('../computed/resource-summary.js');
+const MainResource = require('../computed/main-resource.js');
+const Budget = require('../config/budget.js');
 const i18n = require('../lib/i18n/i18n.js');
 
 const UIStrings = {
@@ -121,7 +123,14 @@ class ResourceBudget extends Audit {
   static async audit(artifacts, context) {
     const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
     const summary = await ResourceSummary.request({devtoolsLog, URL: artifacts.URL}, context);
-    const budget = context.settings.budgets ? context.settings.budgets[0] : undefined;
+    const mainResource = await MainResource.request({URL: artifacts.URL, devtoolsLog}, context);
+    // Clones budget so that the user-supplied version is not mutated.
+    /** @type {Array<LH.Budget>} */
+    const budgets = JSON.parse(JSON.stringify(context.settings.budgets));
+    // Applies the LAST matching budget
+    const budget = budgets ? budgets.reverse().find((b) => {
+      return Budget.urlMatchesPattern(mainResource.url, b.path);
+    }) : undefined;
 
     if (!budget) {
       return {
@@ -130,7 +139,7 @@ class ResourceBudget extends Audit {
       };
     }
 
-    /** @type { LH.Audit.Details.Table['headings'] } */
+    /** @type {LH.Audit.Details.Table['headings']} */
     const headers = [
       {key: 'label', itemType: 'text', text: str_(i18n.UIStrings.columnResourceType)},
       {key: 'requestCount', itemType: 'numeric', text: str_(i18n.UIStrings.columnRequests)},

lighthouse-core/config/budget.js

@@ -5,6 +5,8 @@
  */
 'use strict';
 
+const URL = require('../lib/url-shim.js');
+
 /**
  * @param {unknown} arr
  * @return {arr is Array<Record<string, unknown>>}
@@ -96,6 +98,97 @@ class Budget {
     };
   }
 
+  /**
+   * Validates that path is properly formed. Verifies the quantity and location
+   * of the two robot.txt regex characters: $, *
+   * @param {unknown} val
+   * @return {string}
+   */
+  static validatePath(val) {
+    /*
+     * If no path is specified the budget is assumed to apply to all pages. This makes
+     * budget.json backwards compatible with earlier API versions that did not include path.
+     */
+
+    if ((val === undefined) || (val === null)) {
+      return '/';
+    }
+    const path = /** @type {string} */ (val);
+    const hasLeadingSlash = path.startsWith('/');
+    const validWildcardQuantity = (path.match(/\*/g) || []).length <= 1;
+    const validDollarSignQuantity = (path.match(/\$/g) || []).length <= 1;
+    const validDollarSignPlacement = !path.includes('$') || path.endsWith('$');
+
+    const isValid = hasLeadingSlash && validWildcardQuantity
+      && validDollarSignQuantity && validDollarSignPlacement;
+
+    if (!isValid) {
+      throw new Error(`Invalid path ${path}. ` +
+        `'Path' should be specified using the 'robots.txt' format.\n` +
+        `Learn more about the 'robots.txt' format here:\n` +
+        `https://developers.google.com/search/reference/robots_txt#url-matching-based-on-path-values`);
+    }
+    return path;
+  }
+
+  /**
+   * Determines whether a URL matches against a robots.txt-style "path".
+   * @param {string} url
+   * @param {string} pattern
+   * @return {boolean}
+   */
+  static urlMatchesPattern(url, pattern) {
+    /*
+     * Pattern should use the robots.txt format. E.g. "/*-article.html" or "/". Reference:
+     * https://developers.google.com/search/reference/robots_txt#url-matching-based-on-path-values
+     */
+
+    const urlObj = new URL(url);
+    const urlPath = urlObj.pathname + urlObj.search;
+
+    const hasWildcard = pattern.includes('*');
+    const hasDollarSign = pattern.includes('$');
+
+    /**
+     * There are 4 different cases of path strings.
+     * Paths should have already been validated with #validatePath.
+     *
+     * Case #1: No special characters
+     * Example: "/cat"
+     * Behavior: URL should start with given pattern.
+     */
+    if (!hasWildcard && !hasDollarSign) {
+      return urlPath.startsWith(pattern);
+    /**
+     * Case #2: $ only
+     * Example: "/js$"
+     * Behavior: URL should be identical to pattern.
+     */
+    } else if (!hasWildcard && hasDollarSign) {
+      return urlPath === pattern.slice(0, -1);
+    /**
+     * Case #3: * only
+     * Example: "/vendor*chunk"
+     * Behavior: URL should start with the string pattern that comes before the wildcard
+     * & later in the string contain the string pattern that comes after the wildcard.
+     */
+    } else if (hasWildcard && !hasDollarSign) {
+      const [beforeWildcard, afterWildcard] = pattern.split('*');
+      const remainingUrl = urlPath.slice(beforeWildcard.length);
+      return urlPath.startsWith(beforeWildcard) && remainingUrl.includes(afterWildcard);
+    /**
+     * Case #4: $ and *
+     * Example: "/vendor*chunk.js$"
+     * Behavior: URL should start with the string pattern that comes before the wildcard
+     * & end with the string pattern that comes after the wildcard.
+     */
+    } else if (hasWildcard && hasDollarSign) {
+      const [beforeWildcard, afterWildcard] = pattern.split('*');
+      return urlPath.startsWith(beforeWildcard) && urlPath.endsWith(afterWildcard.slice(0, -1));
+    }
+    return false;
+  }
+
   /**
    * @param {Record<string, unknown>} timingBudget
    * @return {LH.Budget.TimingBudget}
@@ -147,9 +240,11 @@ class Budget {
       /** @type {LH.Budget} */
       const budget = {};
 
-      const {resourceSizes, resourceCounts, timings, ...invalidRest} = b;
+      const {path, resourceSizes, resourceCounts, timings, ...invalidRest} = b;
       Budget.assertNoExcessProperties(invalidRest, 'Budget');
 
+      budget.path = Budget.validatePath(path);
+
       if (isArrayOfUnknownObjects(resourceSizes)) {
         budget.resourceSizes = resourceSizes.map(Budget.validateResourceBudget);
         Budget.assertNoDuplicateStrings(budget.resourceSizes.map(r => r.resourceType),

lighthouse-core/test/audits/performance-budget-test.js

@@ -23,14 +23,15 @@ describe('Performance: Resource budgets audit', () => {
           {url: 'http://third-party.com/file.jpg', resourceType: 'Image', transferSize: 70},
         ]),
       },
-      URL: {requestedURL: 'http://example.com', finalURL: 'http://example.com'},
+      URL: {requestedUrl: 'http://example.com', finalURL: 'http://example.com'},
     };
     context = {computedCache: new Map(), settings: {}};
   });
 
   describe('with a budget.json', () => {
     beforeEach(() => {
       context.settings.budgets = [{
+        path: '/',
         resourceSizes: [
           {
             resourceType: 'script',
@@ -86,6 +87,7 @@ describe('Performance: Resource budgets audit', () => {
 
       it('convert budgets from kilobytes to bytes during calculations', async () => {
         context.settings.budgets = [{
+          path: '/',
           resourceSizes: [
             {
               resourceType: 'document',
@@ -98,13 +100,21 @@ describe('Performance: Resource budgets audit', () => {
       });
     });
 
+    it('does not mutate the budget config', async () => {
+      const configBefore = JSON.parse(JSON.stringify(context.settings.budgets));
+      await ResourceBudgetAudit.audit(artifacts, context);
+      const configAfter = JSON.parse(JSON.stringify(context.settings.budgets));
+      expect(configBefore).toEqual(configAfter);
+    });
+
     it('only includes rows for resource types with budgets', async () => {
       const result = await ResourceBudgetAudit.audit(artifacts, context);
       expect(result.details.items).toHaveLength(2);
     });
 
     it('sorts rows by descending file size overage', async () => {
       context.settings.budgets = [{
+        path: '/',
         resourceSizes: [
           {
             resourceType: 'document',
@@ -126,27 +136,54 @@ describe('Performance: Resource budgets audit', () => {
         expect(item.size).toBeGreaterThanOrEqual(items[index + 1].size);
       });
     });
-
-    it('uses the first budget in budgets', async () => {
-      context.settings.budgets = [{
-        resourceSizes: [
-          {
-            resourceType: 'image',
-            budget: 0,
-          },
-        ],
-      },
-      {
-        resourceSizes: [
-          {
-            resourceType: 'script',
-            budget: 0,
-          },
-        ],
-      },
-      ];
-      const result = await ResourceBudgetAudit.audit(artifacts, context);
-      expect(result.details.items[0].resourceType).toBe('image');
+    describe('budget path', () => {
+      it('applies the last matching budget', async () => {
+        context.settings.budgets = [{
+          path: '/',
+          resourceSizes: [
+            {
+              resourceType: 'script',
+              budget: 0,
+            },
+          ],
+        },
+        {
+          path: '/file.html',
+          resourceSizes: [
+            {
+              resourceType: 'image',
+              budget: 0,
+            },
+          ],
+        },
+        {
+          path: '/not-a-match',
+          resourceSizes: [
+            {
+              resourceType: 'document',
+              budget: 0,
+            },
+          ],
+        },
+        ];
+        const result = await ResourceBudgetAudit.audit(artifacts, context);
+        expect(result.details.items[0].resourceType).toBe('image');
+      });
+      it('returns "audit does not apply" if no budget matches', async () => {
+        context.settings.budgets = [{
+          path: '/not-a-match',
+          resourceSizes: [
+            {
+              resourceType: 'script',
+              budget: 0,
+            },
+          ],
+        },
+        ];
+        const result = await ResourceBudgetAudit.audit(artifacts, context);
+        expect(result.details).toBeUndefined();
+        expect(result.notApplicable).toBe(true);
+      });
     });
   });