Netcatty/electron/preload/api.stageUploadFile.test.cjs

"use strict";

const assert = require("node:assert/strict");
const fs = require("node:fs");
const os = require("node:os");
const path = require("node:path");
const test = require("node:test");

const { createPreloadApi } = require("./api.cjs");

function createFile(name, chunks) {
  let index = 0;
  return {
    name,
    stream: () => ({
      getReader: () => ({
        async read() {
          if (index >= chunks.length) return { done: true };
          return { done: false, value: Uint8Array.from(chunks[index++]) };
        },
        releaseLock() {},
      }),
    }),
  };
}

function createBlockingFile(name) {
  let markReadStarted;
  let finishRead;
  const readStarted = new Promise((resolve) => { markReadStarted = resolve; });
  return {
    file: {
      name,
      stream: () => ({
        getReader: () => ({
          read() {
            markReadStarted();
            return new Promise((resolve) => { finishRead = resolve; });
          },
          cancel() {
            finishRead?.({ done: true });
            return Promise.resolve();
          },
          releaseLock() {},
        }),
      }),
    },
    readStarted,
  };
}

test("superseding pathless upload staging uses an independent temp file", async (t) => {
  const dir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "netcatty-preload-stage-race-"));
  t.after(() => fs.promises.rm(dir, { recursive: true, force: true }));
  const created = [];
  const deleted = [];
  const ipcRenderer = {
    on() {},
    removeListener() {},
    async invoke(channel, payload) {
      if (channel === "netcatty:tempdir:createUploadPath") {
        const localPath = path.join(dir, `${payload.transferId}_${payload.fileName}.part`);
        created.push({ payload, localPath });
        return localPath;
      }
      if (channel === "netcatty:deleteTempFile") {
        deleted.push(payload.filePath);
        await fs.promises.unlink(payload.filePath).catch(() => {});
        return { success: true };
      }
      throw new Error(`Unexpected IPC call: ${channel}`);
    },
  };
  const api = createPreloadApi({ ipcRenderer, webUtils: {} });
  const firstFile = createBlockingFile("same.bin");

  const first = api.stageUploadFile(firstFile.file, "same-transfer");
  await firstFile.readStarted;
  const second = api.stageUploadFile(createFile("same.bin", [[4, 5, 6]]), "same-transfer");

  await assert.rejects(first, /superseded/i);
  const secondPath = await second;

  assert.equal(created.length, 2);
  assert.notEqual(created[0].payload.transferId, created[1].payload.transferId);
  assert.notEqual(created[0].localPath, created[1].localPath);
  assert.equal(secondPath, created[1].localPath);
  assert.deepEqual(await fs.promises.readFile(secondPath), Buffer.from([4, 5, 6]));
  await assert.rejects(fs.promises.stat(created[0].localPath), { code: "ENOENT" });
  assert.deepEqual(deleted, [created[0].localPath]);
});

test("failed upload path allocation releases the staging controller", async () => {
  const api = createPreloadApi({
    webUtils: {},
    ipcRenderer: {
      on() {},
      removeListener() {},
      async invoke(channel) {
        if (channel === "netcatty:tempdir:createUploadPath") throw new Error("path unavailable");
        throw new Error(`Unexpected IPC call: ${channel}`);
      },
    },
  });

  await assert.rejects(api.stageUploadFile(createFile("file.bin", [[1]]), "failed-path"), /path unavailable/);
  assert.deepEqual(await api.cancelStagedUploadFile("failed-path"), { success: false });
});