@mycadet/assistant 0.12.10 → 0.13.0

package/src/__tests__/migration-export-streaming.test.ts

@@ -1,350 +0,0 @@
-/**
- * Integration tests for the streaming vbundle export builder.
- *
- * Tests cover:
- * - Format parity: streaming builder produces archives identical to sync builder
- * - SHA-256 integrity: manifest checksums match actual file content
- * - Temp file lifecycle: cleanup removes the temp file
- * - Cleanup idempotency: calling cleanup twice doesn't throw
- * - Round-trip: streamExportVBundle -> validateVBundle succeeds
- */
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { gunzipSync } from "node:zlib";
-import { beforeAll, describe, expect, test } from "bun:test";
-
-const testDir = process.env.CADET_WORKSPACE_DIR!;
-const testDbDir = join(testDir, "data", "db");
-const testDbPath = join(testDbDir, "assistant.db");
-const testConfigPath = join(testDir, "config.json");
-
-process.env.DISABLE_HTTP_AUTH = "true";
-
-import { defaultV1Options } from "../runtime/migrations/__tests__/v1-test-helpers.js";
-import {
-  buildExportVBundle,
-  streamExportVBundle,
-} from "../runtime/migrations/vbundle-builder.js";
-import { validateVBundle } from "../runtime/migrations/vbundle-validator.js";
-// Test fixture data: a minimal SQLite header to simulate a real database file
-const SQLITE_HEADER = new Uint8Array([
-  0x53, 0x51, 0x4c, 0x69, 0x74, 0x65, 0x20, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74,
-  0x20, 0x33, 0x00,
-]);
-const TEST_CONFIG = { provider: "anthropic", model: "test-model" };
-
-// Generate a synthetic large file (~10 MB of repeated data)
-const LARGE_FILE_SIZE = 10 * 1024 * 1024; // 10 MB
-const LARGE_FILE_NAME = "large-test-data.txt";
-
-function generateLargeFileContent(): Buffer {
-  const line =
-    "This is a line of repeated test data for streaming export verification.\n";
-  const lineBuffer = Buffer.from(line);
-  const buf = Buffer.alloc(LARGE_FILE_SIZE);
-  for (let offset = 0; offset < LARGE_FILE_SIZE; offset += lineBuffer.length) {
-    const remaining = LARGE_FILE_SIZE - offset;
-    lineBuffer.copy(buf, offset, 0, Math.min(lineBuffer.length, remaining));
-  }
-  return buf;
-}
-
-beforeAll(() => {
-  // Write test fixture files so the export reads real data
-  mkdirSync(testDbDir, { recursive: true });
-  writeFileSync(testDbPath, SQLITE_HEADER);
-  writeFileSync(testConfigPath, JSON.stringify(TEST_CONFIG, null, 2));
-  writeFileSync(join(testDir, LARGE_FILE_NAME), generateLargeFileContent());
-});
-
-// ---------------------------------------------------------------------------
-// Tar parsing helper (mirrors vbundle-validator's internal parser)
-// ---------------------------------------------------------------------------
-
-interface TarEntry {
-  name: string;
-  data: Uint8Array;
-}
-
-function parseTarEntries(gzippedData: Uint8Array): TarEntry[] {
-  const tarData = gunzipSync(gzippedData);
-  const entries: TarEntry[] = [];
-  let offset = 0;
-  const BLOCK_SIZE = 512;
-
-  while (offset + BLOCK_SIZE <= tarData.length) {
-    const header = tarData.subarray(offset, offset + BLOCK_SIZE);
-    if (header.every((b) => b === 0)) {
-      break;
-    }
-
-    let end = 0;
-    while (end < 100 && header[end] !== 0) {
-      end++;
-    }
-    const name = new TextDecoder().decode(header.subarray(0, end));
-
-    let sizeEnd = 124;
-    while (sizeEnd < 136 && header[sizeEnd] !== 0) {
-      sizeEnd++;
-    }
-    const sizeStr = new TextDecoder().decode(header.subarray(124, sizeEnd));
-    const size = parseInt(sizeStr, 8) || 0;
-
-    const dataStart = offset + BLOCK_SIZE;
-    const data = tarData.subarray(dataStart, dataStart + size);
-    const dataBlocks = Math.ceil(size / BLOCK_SIZE);
-
-    if (header[156] === "0".charCodeAt(0) || header[156] === 0) {
-      entries.push({ name, data: new Uint8Array(data) });
-    }
-
-    offset = dataStart + dataBlocks * BLOCK_SIZE;
-  }
-
-  return entries;
-}
-
-function sha256Hex(data: Uint8Array): string {
-  return createHash("sha256").update(data).digest("hex");
-}
-
-// ---------------------------------------------------------------------------
-// Streaming export tests
-// ---------------------------------------------------------------------------
-
-describe("streamExportVBundle", () => {
-  test("returns a temp file that exists on disk", async () => {
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    try {
-      expect(existsSync(result.tempPath)).toBe(true);
-      expect(result.size).toBeGreaterThan(0);
-    } finally {
-      await result.cleanup();
-    }
-  });
-
-  test("manifest contains correct SHA-256 checksums for all files", async () => {
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    try {
-      const archiveData = new Uint8Array(readFileSync(result.tempPath));
-      const entries = parseTarEntries(archiveData);
-
-      for (const fileEntry of result.manifest.contents) {
-        const tarEntry = entries.find((e) => e.name === fileEntry.path);
-        expect(tarEntry).toBeDefined();
-        expect(sha256Hex(tarEntry!.data)).toBe(fileEntry.sha256);
-      }
-    } finally {
-      await result.cleanup();
-    }
-  });
-
-  test("decompressed archive produces same files as buildExportVBundle", async () => {
-    const streamResult = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    try {
-      const syncResult = buildExportVBundle({
-        workspaceDir: testDir,
-        ...defaultV1Options(),
-      });
-
-      const streamArchiveData = new Uint8Array(
-        readFileSync(streamResult.tempPath),
-      );
-      const streamEntries = parseTarEntries(streamArchiveData);
-      const syncEntries = parseTarEntries(syncResult.archive);
-
-      // Filter out manifest.json — compare only data files
-      const streamFileEntries = streamEntries
-        .filter((e) => e.name !== "manifest.json")
-        .sort((a, b) => a.name.localeCompare(b.name));
-      const syncFileEntries = syncEntries
-        .filter((e) => e.name !== "manifest.json")
-        .sort((a, b) => a.name.localeCompare(b.name));
-
-      // Same set of files
-      expect(streamFileEntries.map((e) => e.name)).toEqual(
-        syncFileEntries.map((e) => e.name),
-      );
-
-      // Same content (verified via checksums)
-      for (let i = 0; i < streamFileEntries.length; i++) {
-        expect(sha256Hex(streamFileEntries[i].data)).toBe(
-          sha256Hex(syncFileEntries[i].data),
-        );
-      }
-
-      // Same manifest file entries (excluding timing fields)
-      const streamManifestFiles = streamResult.manifest.contents
-        .slice()
-        .sort((a, b) => a.path.localeCompare(b.path));
-      const syncManifestFiles = syncResult.manifest.contents
-        .slice()
-        .sort((a, b) => a.path.localeCompare(b.path));
-
-      expect(streamManifestFiles.map((f) => f.path)).toEqual(
-        syncManifestFiles.map((f) => f.path),
-      );
-      expect(streamManifestFiles.map((f) => f.sha256)).toEqual(
-        syncManifestFiles.map((f) => f.sha256),
-      );
-      expect(streamManifestFiles.map((f) => f.size_bytes)).toEqual(
-        syncManifestFiles.map((f) => f.size_bytes),
-      );
-    } finally {
-      await streamResult.cleanup();
-    }
-  });
-
-  test("cleanup removes the temp file", async () => {
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    expect(existsSync(result.tempPath)).toBe(true);
-    await result.cleanup();
-    expect(existsSync(result.tempPath)).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Round-trip test
-// ---------------------------------------------------------------------------
-
-describe("streamExportVBundle round-trip", () => {
-  test("streaming archive passes validateVBundle with matching manifest", async () => {
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    try {
-      const archiveData = new Uint8Array(readFileSync(result.tempPath));
-      const validationResult = validateVBundle(archiveData);
-
-      expect(validationResult.is_valid).toBe(true);
-      expect(validationResult.errors).toHaveLength(0);
-      expect(validationResult.manifest).toBeDefined();
-
-      // Verify manifest fields match
-      expect(validationResult.manifest!.schema_version).toBe(
-        result.manifest.schema_version,
-      );
-      expect(validationResult.manifest!.checksum).toBe(
-        result.manifest.checksum,
-      );
-
-      // Verify file entries match
-      const validatedFiles = validationResult
-        .manifest!.contents.slice()
-        .sort((a, b) => a.path.localeCompare(b.path));
-      const resultFiles = result.manifest.contents
-        .slice()
-        .sort((a, b) => a.path.localeCompare(b.path));
-
-      expect(validatedFiles).toEqual(resultFiles);
-    } finally {
-      await result.cleanup();
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Streaming config sanitization test
-// ---------------------------------------------------------------------------
-
-describe("streamExportVBundle config sanitization", () => {
-  test("exported config.json has environment-specific fields stripped", async () => {
-    // Write a config with environment-specific fields that should be stripped
-    const configWithEnvFields = {
-      provider: "anthropic",
-      model: "test-model",
-      ingress: {
-        publicBaseUrl: "https://my-tunnel.example.com",
-        enabled: true,
-        port: 8080,
-      },
-      daemon: {
-        autoStart: true,
-        logLevel: "debug",
-      },
-      skills: {
-        load: {
-          extraDirs: ["/home/user/custom-skills", "/opt/skills"],
-          autoReload: true,
-        },
-      },
-      memory: { enabled: true },
-    };
-    writeFileSync(testConfigPath, JSON.stringify(configWithEnvFields, null, 2));
-
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    try {
-      const archiveData = new Uint8Array(readFileSync(result.tempPath));
-      const entries = parseTarEntries(archiveData);
-
-      const configEntry = entries.find(
-        (e) => e.name === "workspace/config.json",
-      );
-      expect(configEntry).toBeDefined();
-
-      const parsedConfig = JSON.parse(
-        new TextDecoder().decode(configEntry!.data),
-      );
-
-      // Environment-specific fields should be stripped/reset
-      expect(parsedConfig.ingress.publicBaseUrl).toBe("");
-      expect(parsedConfig.ingress.enabled).toBeUndefined();
-      expect(parsedConfig.daemon).toBeUndefined();
-      expect(parsedConfig.skills.load.extraDirs).toEqual([]);
-
-      // Non-environment-specific fields should be preserved
-      expect(parsedConfig.provider).toBe("anthropic");
-      expect(parsedConfig.model).toBe("test-model");
-      expect(parsedConfig.ingress.port).toBe(8080);
-      expect(parsedConfig.skills.load.autoReload).toBe(true);
-      expect(parsedConfig.memory.enabled).toBe(true);
-    } finally {
-      // Restore original config for subsequent tests
-      writeFileSync(testConfigPath, JSON.stringify(TEST_CONFIG, null, 2));
-      await result.cleanup();
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Cleanup idempotency test
-// ---------------------------------------------------------------------------
-
-describe("streamExportVBundle cleanup", () => {
-  test("calling cleanup twice does not throw", async () => {
-    const result = await streamExportVBundle({
-      workspaceDir: testDir,
-      ...defaultV1Options(),
-    });
-
-    await result.cleanup();
-    // Second call should not throw
-    await result.cleanup();
-
-    expect(existsSync(result.tempPath)).toBe(false);
-  });
-});