[Init] Initial commit - NetMesh terminal manager

lib/sftpFileUtils.test.ts

@@ -0,0 +1,145 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  captureDropPayload,
+  formatDropScanLabel,
+  getFileExtension,
+  hasFileExtension,
+  localTreeToDropEntries,
+  materializeDropEntries,
+  type LocalTreeListEntry,
+} from "./sftpFileUtils.ts";
+
+test("hasFileExtension identifies extensionless and dotted filenames", () => {
+  assert.equal(hasFileExtension("nginx"), false);
+  assert.equal(hasFileExtension("my-binary"), false);
+  assert.equal(hasFileExtension(".git"), false);
+  assert.equal(getFileExtension("nginx"), "file");
+
+  assert.equal(hasFileExtension("readme.txt"), true);
+  assert.equal(hasFileExtension(".bashrc"), false);
+  assert.equal(hasFileExtension("archive.tar.gz"), true);
+});
+
+test("formatDropScanLabel summarizes dropped root names", () => {
+  assert.equal(formatDropScanLabel([]), "Scanning files...");
+  assert.equal(formatDropScanLabel([{ name: "docs", isDirectory: true }]), "docs");
+  assert.equal(
+    formatDropScanLabel([
+      { name: "a", isDirectory: true },
+      { name: "b", isDirectory: true },
+    ]),
+    "a, b",
+  );
+  assert.equal(
+    formatDropScanLabel([
+      { name: "a", isDirectory: true },
+      { name: "b", isDirectory: true },
+      { name: "c", isDirectory: true },
+    ]),
+    "a, b +1",
+  );
+});
+
+test("captureDropPayload reads webkit entries synchronously", () => {
+  const file = new File(["x"], "note.txt");
+  Object.defineProperty(file, "path", { value: "/tmp/note.txt" });
+  const dataTransfer = {
+    items: [{
+      kind: "file",
+      getAsFile: () => file,
+      webkitGetAsEntry: () => ({
+        name: "note.txt",
+        isFile: true,
+        isDirectory: false,
+      }),
+    }],
+    files: [file],
+  } as unknown as DataTransfer;
+
+  const payload = captureDropPayload(dataTransfer);
+  assert.equal(payload.roots.length, 1);
+  assert.equal(payload.roots[0].name, "note.txt");
+  assert.equal(payload.roots[0].isDirectory, false);
+  assert.equal(payload.roots[0].localPath, "/tmp/note.txt");
+});
+
+test("materializeDropEntries prefers listLocalTree for directory roots with paths", async () => {
+  const progress: Array<{ fileCount: number; directoryCount: number }> = [];
+  const tree: LocalTreeListEntry[] = [
+    {
+      localPath: "/tmp/project",
+      relativePath: "project",
+      type: "directory",
+      size: 0,
+      lastModified: 1,
+    },
+    {
+      localPath: "/tmp/project/src",
+      relativePath: "project/src",
+      type: "directory",
+      size: 0,
+      lastModified: 1,
+    },
+    {
+      localPath: "/tmp/project/src/main.ts",
+      relativePath: "project/src/main.ts",
+      type: "file",
+      size: 12,
+      lastModified: 2,
+    },
+  ];
+
+  const entries = await materializeDropEntries(
+    {
+      roots: [{
+        name: "project",
+        isDirectory: true,
+        localPath: "/tmp/project",
+      }],
+      filesFallback: [],
+    },
+    {
+      listLocalTree: async (path, options) => {
+        assert.equal(path, "/tmp/project");
+        options?.onProgress?.({ fileCount: 1, directoryCount: 2, entryCount: 3 });
+        return tree;
+      },
+      onProgress: (p) => progress.push({ fileCount: p.fileCount, directoryCount: p.directoryCount }),
+    },
+  );
+
+  assert.deepEqual(
+    entries.map((entry) => ({
+      relativePath: entry.relativePath,
+      isDirectory: entry.isDirectory,
+      localPath: entry.localPath,
+      size: entry.size,
+    })),
+    [
+      { relativePath: "project", isDirectory: true, localPath: "/tmp/project", size: undefined },
+      { relativePath: "project/src", isDirectory: true, localPath: "/tmp/project/src", size: undefined },
+      {
+        relativePath: "project/src/main.ts",
+        isDirectory: false,
+        localPath: "/tmp/project/src/main.ts",
+        size: 12,
+      },
+    ],
+  );
+  assert.ok(progress.some((p) => p.fileCount === 1 && p.directoryCount === 2));
+});
+
+test("localTreeToDropEntries preserves file sizes without File handles", () => {
+  const entries = localTreeToDropEntries([{
+    localPath: "/tmp/a.txt",
+    relativePath: "a.txt",
+    type: "file",
+    size: 42,
+    lastModified: 9,
+  }]);
+  assert.equal(entries[0].file, null);
+  assert.equal(entries[0].localPath, "/tmp/a.txt");
+  assert.equal(entries[0].size, 42);
+});