browser-commander 0.18.0 → 0.19.0

package/tests/unit/downloads/manager.test.js

@@ -338,6 +338,137 @@ describe('download manager (issue #88)', () => {
       assert.match(cancelled[0].failure, /canceled/);
     });
 
+    it('should wait for staged bytes that land after the completion event', async () => {
+      // Issue #92: Chromium writes `<guid>.crdownload` and renames it, so the
+      // completion event can arrive before `<guid>` is openable. Publishing on
+      // the event alone turned a download that succeeded into
+      // `ENOENT ... .browser-commander-staging/<guid>`.
+      const session = createFakeCdpSession();
+      manager = await cdpManagerOver(session);
+      const completed = collect(DOWNLOAD_EVENT.COMPLETED);
+      const failed = collect(DOWNLOAD_EVENT.FAILED);
+
+      const guid = 'guid-0010';
+      const stagedPath = path.join(root, STAGING_DIRECTORY, guid);
+      session.emit('Browser.downloadWillBegin', {
+        guid,
+        url: 'https://example.com/late.pdf',
+        suggestedFilename: 'late.pdf',
+      });
+      // The event first, the bytes afterwards - the ordering from the report.
+      session.emit('Browser.downloadProgress', { guid, state: 'completed' });
+      await yieldToEngine();
+      assert.deepStrictEqual(completed, [], 'published before the bytes exist');
+      await fs.writeFile(stagedPath, 'late body');
+
+      await manager.idle();
+
+      assert.deepStrictEqual(failed, []);
+      assert.strictEqual(completed.length, 1);
+      assert.strictEqual(
+        await fs.readFile(completed[0].path, 'utf8'),
+        'late body'
+      );
+      assert.deepStrictEqual(
+        await fs.readdir(path.join(root, STAGING_DIRECTORY)),
+        []
+      );
+    });
+
+    it('should not claim bytes while the partial file is still being written', async () => {
+      const session = createFakeCdpSession();
+      manager = await cdpManagerOver(session);
+      const completed = collect(DOWNLOAD_EVENT.COMPLETED);
+
+      const guid = 'guid-0011';
+      const stagedPath = path.join(root, STAGING_DIRECTORY, guid);
+      session.emit('Browser.downloadWillBegin', {
+        guid,
+        url: 'https://example.com/partial.pdf',
+        suggestedFilename: 'partial.pdf',
+      });
+      // A half-written file under the final name, with Chromium's own
+      // in-progress marker still beside it.
+      await fs.writeFile(stagedPath, 'half');
+      await fs.writeFile(`${stagedPath}.crdownload`, 'rest');
+      session.emit('Browser.downloadProgress', { guid, state: 'completed' });
+      await yieldToEngine();
+      await yieldToEngine();
+      assert.deepStrictEqual(completed, [], 'claimed a half-written file');
+
+      await fs.rm(`${stagedPath}.crdownload`);
+      await fs.writeFile(stagedPath, 'half and rest');
+      await manager.idle();
+
+      assert.strictEqual(completed.length, 1);
+      assert.strictEqual(
+        await fs.readFile(completed[0].path, 'utf8'),
+        'half and rest'
+      );
+    });
+
+    it('should report a completion whose bytes never arrive as a failure', async () => {
+      const session = createFakeCdpSession();
+      manager = await createDownloadManager({
+        engine: 'puppeteer',
+        directory: root,
+        browser: {
+          target: () => ({ createCDPSession: async () => session }),
+        },
+        stagingTimeout: 60,
+        stagingPollInterval: 5,
+      });
+      const failed = collect(DOWNLOAD_EVENT.FAILED);
+      const completed = collect(DOWNLOAD_EVENT.COMPLETED);
+
+      session.emit('Browser.downloadWillBegin', {
+        guid: 'guid-0012',
+        url: 'https://example.com/ghost.pdf',
+        suggestedFilename: 'ghost.pdf',
+      });
+      session.emit('Browser.downloadProgress', {
+        guid: 'guid-0012',
+        state: 'completed',
+      });
+      await manager.idle();
+
+      assert.deepStrictEqual(completed, []);
+      assert.strictEqual(failed.length, 1);
+      assert.match(failed[0].failure, /was not readable within 60ms/);
+      assert.match(failed[0].failure, /guid-0012/);
+    });
+
+    it('should keep a capture waiting until the staged bytes are readable', async () => {
+      const session = createFakeCdpSession();
+      manager = await cdpManagerOver(session);
+
+      const guid = 'guid-0013';
+      const stagedPath = path.join(root, STAGING_DIRECTORY, guid);
+      const artifact = await manager.capture({
+        timeout: 5000,
+        action: async () => {
+          session.emit('Browser.downloadWillBegin', {
+            guid,
+            url: 'https://example.com/captured.pdf',
+            suggestedFilename: 'captured.pdf',
+          });
+          session.emit('Browser.downloadProgress', {
+            guid,
+            state: 'completed',
+          });
+          setTimeout(() => {
+            fs.writeFile(stagedPath, 'captured body').catch(() => {});
+          }, 40);
+        },
+      });
+
+      assert.strictEqual(artifact.state, DOWNLOAD_EVENT.COMPLETED);
+      assert.strictEqual(
+        await fs.readFile(artifact.path, 'utf8'),
+        'captured body'
+      );
+    });
+
     it('should ignore progress for a download it never saw start', async () => {
       const session = createFakeCdpSession();
       manager = await cdpManagerOver(session);

package/tests/unit/downloads/staging.test.js

@@ -0,0 +1,117 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import {
+  DEFAULT_STAGING_POLL_INTERVAL,
+  DEFAULT_STAGING_TIMEOUT,
+  describeStagingTimeout,
+  STAGING_IN_PROGRESS_SUFFIXES,
+  waitForStagedFile,
+} from '../../../src/downloads/staging.js';
+import { useTempDownloadDirectory } from '../../helpers/download-fixtures.js';
+
+describe('waiting for staged bytes (issue #92)', () => {
+  const directory = useTempDownloadDirectory();
+
+  it('should report a file that is already complete', async () => {
+    const staged = path.join(directory.path, 'guid-ready');
+    await fs.writeFile(staged, 'complete body');
+
+    const settled = await waitForStagedFile({ path: staged, timeout: 1000 });
+
+    assert.strictEqual(settled.ready, true);
+    assert.strictEqual(settled.bytes, 'complete body'.length);
+    assert.strictEqual(settled.reason, null);
+  });
+
+  it('should wait for a file that appears after the completion event', async () => {
+    // This is issue #92 exactly: the browser says "completed" and the rename
+    // Chromium does behind it has not become visible yet.
+    const staged = path.join(directory.path, 'guid-late');
+    const appear = setTimeout(() => {
+      fs.writeFile(staged, 'late body').catch(() => {});
+    }, 60);
+
+    const settled = await waitForStagedFile({
+      path: staged,
+      timeout: 5000,
+      interval: 5,
+    });
+    clearTimeout(appear);
+
+    assert.strictEqual(settled.ready, true, settled.reason ?? '');
+    assert.strictEqual(settled.bytes, 'late body'.length);
+  });
+
+  it('should keep waiting while the file is still growing', async () => {
+    const staged = path.join(directory.path, 'guid-growing');
+    await fs.writeFile(staged, 'a');
+    const grow = setInterval(() => {
+      fs.appendFile(staged, 'a').catch(() => {});
+    }, 5);
+    setTimeout(() => clearInterval(grow), 80);
+
+    const settled = await waitForStagedFile({
+      path: staged,
+      timeout: 5000,
+      interval: 5,
+    });
+    clearInterval(grow);
+
+    assert.strictEqual(settled.ready, true, settled.reason ?? '');
+    // Two equal readings are what ends the wait, so the file had stopped
+    // growing before it was declared ready.
+    assert.strictEqual(settled.bytes, (await fs.stat(staged)).size);
+  });
+
+  it('should not claim a file whose partial sibling is still being written', async () => {
+    const staged = path.join(directory.path, 'guid-partial');
+    await fs.writeFile(staged, 'looks done');
+    await fs.writeFile(`${staged}.crdownload`, 'still writing');
+
+    const settled = await waitForStagedFile({
+      path: staged,
+      timeout: 60,
+      interval: 5,
+    });
+
+    assert.strictEqual(settled.ready, false);
+    assert.match(settled.reason, /\.crdownload file is still being written/);
+  });
+
+  it('should fail explicitly when the bytes never arrive', async () => {
+    const staged = path.join(directory.path, 'guid-missing');
+
+    const settled = await waitForStagedFile({
+      path: staged,
+      timeout: 60,
+      interval: 5,
+    });
+
+    assert.strictEqual(settled.ready, false);
+    assert.strictEqual(settled.bytes, null);
+    assert.match(settled.reason, /has not appeared/);
+  });
+
+  it('should name the file, the budget and what it last saw', () => {
+    const message = describeStagingTimeout({
+      path: '/tmp/root/.browser-commander-staging/guid',
+      timeout: 250,
+      reason: 'the file has not appeared yet',
+    });
+
+    assert.match(message, /reported the download as completed/);
+    assert.match(message, /guid/);
+    assert.match(message, /250ms/);
+    assert.match(message, /has not appeared yet/);
+  });
+
+  it('should ship defaults a download can actually finish within', () => {
+    assert.ok(DEFAULT_STAGING_TIMEOUT >= 1000);
+    assert.ok(DEFAULT_STAGING_POLL_INTERVAL > 0);
+    assert.ok(DEFAULT_STAGING_POLL_INTERVAL < DEFAULT_STAGING_TIMEOUT);
+    assert.ok(STAGING_IN_PROGRESS_SUFFIXES.includes('.crdownload'));
+  });
+});