@cue-dev/retrieval-core 0.1.3 → 0.1.5

package/test/remote-sync.integration.test.ts

@@ -1,4 +1,4 @@
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdtemp, mkdir, rm, symlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
@@ -6,6 +6,7 @@ import {
   RemoteSyncHttpResponseError,
   buildRemoteSyncDeltaFromState,
   collectProjectFileStats,
+  estimateRemoteSyncDeltaRequestSize,
   runRemoteAdaptiveSync,
   runRemoteDeltaSync,
   type RemoteSyncStateFile
@@ -129,6 +130,29 @@ describe("runRemoteDeltaSync", () => {
     expect(stats.get("src/legacy.cts")?.language).toBe("typescript");
   });
 
+  it("skips symlinks that could escape project root", async () => {
+    const root = await createProject();
+    const outside = await mkdtemp(join(tmpdir(), "cue-remote-sync-outside-"));
+    tempDirs.push(outside);
+    await writeFile(join(outside, "secret.txt"), "top-secret\n");
+    await symlink(join(outside, "secret.txt"), join(root, "src", "secret-link.txt"));
+
+    const stats = await collectProjectFileStats(root);
+    expect(stats.has("src/secret-link.txt")).toBe(false);
+  });
+
+  it("fails fast when scan exceeds max_files limit", async () => {
+    const root = await createProject();
+    await writeFile(join(root, "src", "a.ts"), "export const A = 1;\n");
+    await writeFile(join(root, "src", "b.ts"), "export const B = 1;\n");
+
+    await expect(
+      collectProjectFileStats(root, {
+        max_files: 1
+      })
+    ).rejects.toThrow(/max_files/i);
+  });
+
   it("applies add/modify/delete changes incrementally", async () => {
     const root = await createProject();
     await writeFile(join(root, "src", "a.ts"), "export const A = 1;\n");
@@ -228,6 +252,100 @@ describe("runRemoteDeltaSync", () => {
     expect(result.index_version).toBe("idx-v1");
   });
 
+  it("adapts delta batch size when upstream body limit is lower than advertised max_body_bytes", async () => {
+    const root = await createProject();
+    const fileCount = 220;
+    for (let index = 0; index < fileCount; index += 1) {
+      const suffix = String(index).padStart(3, "0");
+      await writeFile(join(root, "src", `body-limit-${suffix}.ts`), `export const VALUE_${suffix} = "${"x".repeat(7000)}";\n`);
+    }
+
+    const ingressBodyLimitBytes = 1_000_000;
+    const payloadSizes: number[] = [];
+    let version = 0;
+    const result = await runRemoteDeltaSync({
+      project_root_path: root,
+      workspace_id: "ws-1",
+      max_body_bytes: 52_428_800,
+      retries: 1,
+      push_delta: async (request) => {
+        const payloadSize = estimateRemoteSyncDeltaRequestSize({
+          project_root_path: request.project_root_path,
+          workspace_id: request.workspace_id,
+          base_index_version: request.base_index_version,
+          upsert_files: request.upsert_files,
+          deleted_paths: request.deleted_paths
+        });
+        payloadSizes.push(payloadSize);
+        if (payloadSize > ingressBodyLimitBytes) {
+          throw new RemoteSyncHttpResponseError("Request Entity Too Large", 413);
+        }
+        version += 1;
+        return {
+          workspace_id: "ws-1",
+          index_version: `idx-v${version}`
+        };
+      }
+    });
+
+    expect(result.changed).toBe(true);
+    expect(result.applied_delta).toEqual({
+      upsert_files: fileCount,
+      deleted_paths: 0
+    });
+    expect(payloadSizes.some((size) => size > ingressBodyLimitBytes)).toBe(true);
+    const successfulPayloads = payloadSizes.filter((size) => size <= ingressBodyLimitBytes);
+    expect(successfulPayloads.length).toBeGreaterThan(0);
+    expect(Math.max(...successfulPayloads)).toBeLessThanOrEqual(ingressBodyLimitBytes);
+  });
+
+  it("adapts delta batch size when upstream times out on oversized batches", async () => {
+    const root = await createProject();
+    const fileCount = 220;
+    for (let index = 0; index < fileCount; index += 1) {
+      const suffix = String(index).padStart(3, "0");
+      await writeFile(join(root, "src", `timeout-limit-${suffix}.ts`), `export const VALUE_${suffix} = "${"x".repeat(7000)}";\n`);
+    }
+
+    const timeoutLimitBytes = 400_000;
+    const payloadSizes: number[] = [];
+    let version = 0;
+    const result = await runRemoteDeltaSync({
+      project_root_path: root,
+      workspace_id: "ws-1",
+      max_body_bytes: 52_428_800,
+      retries: 1,
+      push_delta: async (request) => {
+        const payloadSize = estimateRemoteSyncDeltaRequestSize({
+          project_root_path: request.project_root_path,
+          workspace_id: request.workspace_id,
+          base_index_version: request.base_index_version,
+          upsert_files: request.upsert_files,
+          deleted_paths: request.deleted_paths
+        });
+        payloadSizes.push(payloadSize);
+        if (payloadSize > timeoutLimitBytes) {
+          throw new RemoteSyncHttpResponseError("Gateway Time-out", 504);
+        }
+        version += 1;
+        return {
+          workspace_id: "ws-1",
+          index_version: `idx-timeout-v${version}`
+        };
+      }
+    });
+
+    expect(result.changed).toBe(true);
+    expect(result.applied_delta).toEqual({
+      upsert_files: fileCount,
+      deleted_paths: 0
+    });
+    expect(payloadSizes.some((size) => size > timeoutLimitBytes)).toBe(true);
+    const successfulPayloads = payloadSizes.filter((size) => size <= timeoutLimitBytes);
+    expect(successfulPayloads.length).toBeGreaterThan(0);
+    expect(Math.max(...successfulPayloads)).toBeLessThanOrEqual(timeoutLimitBytes);
+  });
+
   it("retries once with full-upsert when base index is stale", async () => {
     const root = await createProject();
     await writeFile(join(root, "src", "retry.ts"), "export const RETRY = 1;\n");