test(firefox): extract xpi cache helper

development/build/manifest.js

@@ -1,6 +1,8 @@
+const nodeCrypto = require('node:crypto');
 const { promises: fs } = require('fs');
 const path = require('path');
-const childProcess = require('child_process');
+const childProcess = require('node:child_process');
+const watch = require('gulp-watch');
 const { mergeWith, cloneDeep } = require('lodash');
 const { isManifestV3 } = require('../../shared/lib/mv3.utils');
 
@@ -105,30 +107,36 @@ function createManifestTasks({
   });
 
   // testDev: add perms
-  const envTestDev = createTaskForModifyManifestForEnvironment((manifest) => {
-    manifest.permissions = [
-      ...new Set([
-        ...manifest.permissions,
-        'webRequestBlocking',
-        'http://localhost/*',
-        'tabs', // test builds need tabs permission for switchToWindowWithTitle
-      ]),
-    ];
-    loadManifestKey(manifest);
-  });
+  const envTestDev = createTaskForModifyManifestForEnvironment(
+    (manifest) => {
+      manifest.permissions = [
+        ...new Set([
+          ...manifest.permissions,
+          'webRequestBlocking',
+          'http://localhost/*',
+          'tabs', // test builds need tabs permission for switchToWindowWithTitle
+        ]),
+      ];
+      loadManifestKey(manifest);
+    },
+    { setBuildId: true, watch: true },
+  );
 
   // test: add permissions
-  const envTest = createTaskForModifyManifestForEnvironment((manifest) => {
-    manifest.permissions = [
-      ...new Set([
-        ...manifest.permissions,
-        'webRequestBlocking',
-        'http://localhost/*',
-        'tabs', // test builds need tabs permission for switchToWindowWithTitle
-      ]),
-    ];
-    loadManifestKey(manifest);
-  });
+  const envTest = createTaskForModifyManifestForEnvironment(
+    (manifest) => {
+      manifest.permissions = [
+        ...new Set([
+          ...manifest.permissions,
+          'webRequestBlocking',
+          'http://localhost/*',
+          'tabs', // test builds need tabs permission for switchToWindowWithTitle
+        ]),
+      ];
+      loadManifestKey(manifest);
+    },
+    { setBuildId: true },
+  );
 
   const envScriptDist = createTaskForModifyManifestForEnvironment(
     (manifest) => {
@@ -163,9 +171,16 @@ function createManifestTasks({
   return { prod, dev, testDev, test, scriptDist };
 
   // helper for modifying each platform's manifest.json in place
-  function createTaskForModifyManifestForEnvironment(transformFn) {
-    return () => {
-      return Promise.all(
+  function createTaskForModifyManifestForEnvironment(
+    transformFn,
+    { setBuildId = false, watch: shouldWatch = false } = {},
+  ) {
+    let updateQueue = Promise.resolve();
+
+    const updateManifests = async () => {
+      const buildId = setBuildId ? nodeCrypto.randomUUID() : undefined;
+
+      await Promise.all(
         browserPlatforms.map(async (platform) => {
           const manifestPath = path.join(
             '.',
@@ -175,11 +190,31 @@ function createManifestTasks({
           );
           const manifest = await readJson(manifestPath);
           transformFn(manifest);
+          if (buildId) {
+            manifest.build_id = buildId;
+          }
 
           await writeJson(manifest, manifestPath);
         }),
       );
     };
+
+    const queueManifestUpdate = () =>
+      (updateQueue = updateQueue.catch(() => undefined).then(updateManifests));
+
+    return async () => {
+      await queueManifestUpdate();
+
+      if (!shouldWatch) {
+        return;
+      }
+
+      watch(
+        './dist/*/**/*',
+        { ignoreInitial: true, ignored: '**/manifest.json' },
+        () => queueManifestUpdate().catch(console.error),
+      );
+    };
   }
 
   // For non-production builds only, modify the extension's name and description

development/webpack/test/helpers.ts

@@ -125,6 +125,7 @@ export function mockWebpack(
   const entries: Record<string, EntryDescriptionNormalized> = {};
   const compiler = {
     context: '',
+    modifiedFiles: undefined,
     hooks: {
       entryOption: {
         tap(

development/webpack/test/plugins.ManifestPlugin.test.ts

@@ -401,6 +401,34 @@ describe('ManifestPlugin', () => {
         assert.strictEqual(zipEntries.has('filename.js.map'), false);
       }
     });
+
+    it('sets build_id in the emitted manifest when setBuildId is enabled', async () => {
+      const { compiler, compilation, promise } = mockWebpack([], [], []);
+      compiler.context = join(__dirname, 'fixtures/ManifestPlugin/empty');
+      compilation.fullHash = 'test-full-hash';
+
+      const manifestPlugin = new ManifestPlugin({
+        browsers: ['chrome', 'firefox'],
+        manifest_version: 3,
+        version: '1.0.0.0',
+        versionName: '1.0.0',
+        description: null,
+        buildType: 'main',
+        zip: false,
+        setBuildId: true,
+      });
+
+      manifestPlugin.apply(compiler);
+      await promise;
+
+      for (const browser of ['chrome', 'firefox'] as const) {
+        const manifest = JSON.parse(
+          compilation.assets[`${browser}/manifest.json`].source().toString(),
+        );
+
+        assert.strictEqual(manifest.build_id, 'test-full-hash');
+      }
+    });
   });
 
   describe('zip helpers', () => {
@@ -775,6 +803,11 @@ describe('ManifestPlugin', () => {
         'overridden_by_beta',
         'should override base property with beta value',
       );
+      assert.strictEqual(
+        json.build_id,
+        undefined,
+        'should not emit build_id unless setBuildId is enabled',
+      );
     });
 
     it('should apply build type browser manifest overrides on top of all previous layers', async () => {
@@ -1562,19 +1595,17 @@ describe('ManifestPlugin', () => {
       );
 
       // Simulate a watch rebuild where no watched files were modified
-      (compiler as unknown as Record<string, unknown>).modifiedFiles = new Set([
-        '/some/unrelated/file.ts',
-      ]);
+      compiler.modifiedFiles = new Set(['/some/unrelated/file.ts']);
 
       // Trigger a second compilation so resolveEntrypoints runs again
       const { compilation: compilation2, promise: promise2 } = mockWebpack(
         [],
         [],
         [],
       );
-      (compilation2 as unknown as Record<string, unknown>).compiler = compiler;
+      compilation2.compiler = compiler;
       // eslint-disable-next-line dot-notation
-      plugin['hookIntoPipelines'](compilation2 as unknown as Compilation);
+      plugin['hookIntoPipelines'](compilation2);
       await promise2;
 
       // Manifest reference should be the same since prepareManifests was NOT called
@@ -1615,20 +1646,18 @@ describe('ManifestPlugin', () => {
 
       // Simulate a watch rebuild where the base manifest was modified.
       // resolveEntrypoints checks compiler.modifiedFiles.
-      (compiler as unknown as Record<string, unknown>).modifiedFiles = new Set([
-        baseManifestDep,
-      ]);
+      compiler.modifiedFiles = new Set([baseManifestDep]);
 
       // Run apply again to trigger a new compilation with modifiedFiles set
       const { compilation: compilation2, promise: promise2 } = mockWebpack(
         [],
         [],
         [],
       );
-      (compilation2 as unknown as Record<string, unknown>).compiler = compiler;
+      compilation2.compiler = compiler;
       // hookIntoPipelines registers processAssets which calls resolveEntrypoints
       // eslint-disable-next-line dot-notation
-      plugin['hookIntoPipelines'](compilation2 as unknown as Compilation);
+      plugin['hookIntoPipelines'](compilation2);
       await promise2;
 
       // Should still produce valid output (manifests were re-read from disk)

development/webpack/test/webpack.config.test.ts

@@ -10,7 +10,7 @@ import {
   Compiler,
   WebpackPluginInstance,
 } from 'webpack';
-import { noop } from '../utils/helpers';
+import { noop, type Manifest } from '../utils/helpers';
 import { ManifestPlugin } from '../utils/plugins/ManifestPlugin';
 import { getLatestCommit } from '../utils/git';
 import { ManifestPluginOptions } from '../utils/plugins/ManifestPlugin/types';
@@ -25,6 +25,55 @@ function getWebpackInstance(config: Configuration) {
   return webpack(config);
 }
 
+async function withWatching<T>(
+  config: Configuration,
+  callback: (
+    waitForBuild: (trigger?: () => void) => Promise<void>,
+  ) => Promise<T>,
+) {
+  const compiler = webpack(config);
+  // @ts-expect-error - Node types need to be updated.
+  let build = Promise.withResolvers<void>();
+  const watchHandle = compiler.watch({}, (error, stats) => {
+    if (error) {
+      build.reject(error);
+      return;
+    }
+    if (!stats) {
+      build.reject(
+        new Error('Webpack finished watch build without returning stats.'),
+      );
+      return;
+    }
+    if (stats.hasErrors()) {
+      build.reject(new Error('Webpack watch build failed.'));
+      return;
+    }
+    build.resolve();
+  });
+  assert(watchHandle, 'Webpack did not return a watch handle.');
+  const watching = watchHandle;
+
+  const waitForBuild = (trigger?: () => void) => {
+    if (!trigger) {
+      return build.promise;
+    }
+    // @ts-expect-error - Node types need to be updated.
+    build = Promise.withResolvers<void>();
+    trigger();
+    watching.invalidate();
+    return build.promise;
+  };
+
+  try {
+    return await callback(waitForBuild);
+  } finally {
+    await new Promise<void>((resolveClose, rejectClose) =>
+      watching.close((error) => (error ? rejectClose(error) : resolveClose())),
+    );
+  }
+}
+
 /**
  * These tests are aimed at testing conditional branches in webpack.config.ts.
  * These tests do *not* test the actual webpack build process itself, or that
@@ -166,6 +215,7 @@ ${Object.entries(env)
       ],
       key: CHROME_MANIFEST_KEY_NON_PRODUCTION,
     });
+    assert.strictEqual(manifestPlugin.options.setBuildId, false);
     assert.strictEqual(manifestPlugin.options.zip, false);
     const manifestOpts = manifestPlugin.options as ManifestPluginOptions<true>;
     assert.strictEqual(manifestOpts.zipOptions, undefined);
@@ -256,6 +306,85 @@ ${Object.entries(env)
     assert.strictEqual(instance.options.devtool, false);
   });
 
+  it('enables manifest build IDs for test builds', () => {
+    const config: Configuration = getWebpackConfig(['--test']);
+    const instance = getWebpackInstance(config);
+    const manifestPlugin = instance.options.plugins.find(
+      (plugin) => plugin && plugin.constructor.name === 'ManifestPlugin',
+    ) as ManifestPlugin<boolean>;
+
+    assert(manifestPlugin, 'Manifest plugin should be present');
+    assert.strictEqual(manifestPlugin.options.setBuildId, true);
+  });
+
+  it('keeps build_id stable for no-op watch rebuilds and changes it for real edits', async () => {
+    using tempDirectory = fs.mkdtempDisposableSync(
+      join(tmpdir(), 'manifest-plugin-watch-test-'),
+    );
+    const manifestDirectory = join(tempDirectory.path, 'manifest', 'v3');
+    const sourceFilePath = join(tempDirectory.path, 'index.js');
+    const outputPath = join(tempDirectory.path, 'dist');
+    const manifestPath = join(outputPath, 'chrome', 'manifest.json');
+
+    const readBuildId = () =>
+      (
+        JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as Manifest & {
+          build_id?: string;
+        }
+      ).build_id;
+
+    const manifest = { manifest_version: 3, name: 'test', version: '1.0.0' };
+    const baseManifestPath = join(manifestDirectory, '_base.json');
+    const writeSource = (source: string | NodeJS.ArrayBufferView) =>
+      fs.writeFileSync(sourceFilePath, source);
+    fs.mkdirSync(manifestDirectory, { recursive: true });
+    fs.writeFileSync(baseManifestPath, JSON.stringify(manifest));
+    writeSource('console.log("v1");\n');
+
+    await withWatching(
+      {
+        mode: 'development',
+        context: tempDirectory.path,
+        entry: { app: sourceFilePath },
+        output: { path: outputPath },
+        plugins: [
+          new ManifestPlugin({
+            browsers: ['chrome'],
+            manifest_version: 3,
+            version: '1.0.0.0',
+            versionName: '1.0.0',
+            description: null,
+            buildType: 'main',
+            zip: false,
+            setBuildId: true,
+          }),
+        ],
+      },
+      async (waitForBuild) => {
+        await waitForBuild();
+        const firstBuildId = readBuildId();
+        assert.ok(firstBuildId, 'expected initial build_id');
+
+        await waitForBuild(() => writeSource(fs.readFileSync(sourceFilePath)));
+        const secondBuildId = readBuildId();
+
+        await waitForBuild(() => writeSource('console.log("v2");\n'));
+        const thirdBuildId = readBuildId();
+
+        assert.strictEqual(
+          secondBuildId,
+          firstBuildId,
+          'expected no-op watch rebuild to keep the same build_id',
+        );
+        assert.notStrictEqual(
+          thirdBuildId,
+          secondBuildId,
+          'expected real file changes to produce a new build_id',
+        );
+      },
+    );
+  });
+
   it('keeps the MYX provider ignore only while the warning still exists', async () => {
     const config: Configuration = getWebpackConfig();
     const myxWarningPattern = /MYXProvider\.mjs/u;