@juppytt/fws 0.1.0

package/test/helpers/harness.ts

@@ -0,0 +1,109 @@
+import { createApp } from '../../src/server/app.js';
+import { resetStore } from '../../src/store/index.js';
+import { generateConfigDir } from '../../src/config/rewrite-cache.js';
+import { generateCACert, startMitmProxy } from '../../src/proxy/mitm.js';
+import { execFile } from 'node:child_process';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import type { Server } from 'node:http';
+
+export interface TestHarness {
+  port: number;
+  /** Direct HTTP fetch against mock server */
+  fetch: (urlPath: string, init?: RequestInit) => Promise<Response>;
+  /** Run gws command (uses discovery cache rewriting for regular commands) */
+  gws: (args: string) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
+  /** Run gws command with MITM proxy (for helper commands like +triage) */
+  gwsProxy: (args: string) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
+  cleanup: () => Promise<void>;
+}
+
+export async function createTestHarness(): Promise<TestHarness> {
+  resetStore();
+
+  const app = createApp();
+  const server: Server = await new Promise((resolve) => {
+    const s = app.listen(0, () => resolve(s));
+  });
+  const port = (server.address() as any).port as number;
+
+  const configDir = await mkdtemp(path.join(tmpdir(), 'fws-test-'));
+  await generateConfigDir(port, configDir);
+
+  // MITM proxy for helper commands
+  const dataDir = await mkdtemp(path.join(tmpdir(), 'fws-test-data-'));
+  const { caPath } = await generateCACert(dataDir);
+  const proxyServer = startMitmProxy(port, 0); // random port
+  const proxyPort = (proxyServer.address() as any).port as number;
+
+  const baseEnv = {
+    ...process.env,
+    GOOGLE_WORKSPACE_CLI_CONFIG_DIR: configDir,
+    GOOGLE_WORKSPACE_CLI_TOKEN: 'fake',
+  };
+
+  const proxyEnv = {
+    ...baseEnv,
+    HTTPS_PROXY: `http://localhost:${proxyPort}`,
+    SSL_CERT_FILE: caPath,
+  };
+
+  const gwsPath = process.env.GWS_PATH || 'gws';
+
+  function parseArgs(args: string): string[] {
+    // Split on whitespace but keep JSON objects and quoted strings as single args
+    const result: string[] = [];
+    let current = '';
+    let braceDepth = 0;
+    let inQuote: string | null = null;
+    for (const char of args) {
+      if (!inQuote && !braceDepth && (char === '"' || char === "'")) {
+        inQuote = char;
+        continue;
+      }
+      if (inQuote && char === inQuote) {
+        inQuote = null;
+        continue;
+      }
+      if (!inQuote) {
+        if (char === '{') braceDepth++;
+        if (char === '}') braceDepth--;
+      }
+      if (char === ' ' && braceDepth === 0 && !inQuote) {
+        if (current) result.push(current);
+        current = '';
+      } else {
+        current += char;
+      }
+    }
+    if (current) result.push(current);
+    return result;
+  }
+
+  function runGws(args: string, env: Record<string, string | undefined>): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    return new Promise((resolve) => {
+      execFile(gwsPath, parseArgs(args), { env, timeout: 10000 }, (err, stdout, stderr) => {
+        resolve({
+          stdout: stdout || '',
+          stderr: stderr || '',
+          exitCode: err ? (err as any).code ?? 1 : 0,
+        });
+      });
+    });
+  }
+
+  return {
+    port,
+    fetch: (urlPath: string, init?: RequestInit) =>
+      globalThis.fetch(`http://localhost:${port}${urlPath}`, init),
+    gws: (args: string) => runGws(args, baseEnv),
+    gwsProxy: (args: string) => runGws(args, proxyEnv),
+    cleanup: async () => {
+      server.close();
+      proxyServer.close();
+      await rm(configDir, { recursive: true, force: true });
+      await rm(dataDir, { recursive: true, force: true });
+    },
+  };
+}

package/test/snapshot.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createTestHarness, type TestHarness } from './helpers/harness.js';
+
+describe('Snapshot', () => {
+  let h: TestHarness;
+
+  beforeAll(async () => {
+    h = await createTestHarness();
+  });
+
+  afterAll(async () => {
+    await h.cleanup();
+  });
+
+  it('save returns current state as JSON', async () => {
+    const res = await h.fetch('/__fws/snapshot/save', { method: 'POST' });
+    const data = await res.json();
+    expect(data.gmail).toBeDefined();
+    expect(data.calendar).toBeDefined();
+    expect(data.drive).toBeDefined();
+  });
+
+  it('full roundtrip: add data, snapshot, reset, verify empty, load, verify data', async () => {
+    // 1. Add some data
+    await h.fetch('/__fws/setup/gmail/message', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ from: 'snap@example.com', subject: 'Snapshot Test', body: 'snapshot body' }),
+    });
+    await h.fetch('/__fws/setup/calendar/event', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ summary: 'Snapshot Event', start: '2026-06-01T10:00:00Z', duration: '1h' }),
+    });
+    await h.fetch('/__fws/setup/drive/file', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name: 'snapshot-file.txt' }),
+    });
+
+    // 2. Snapshot
+    const snapRes = await h.fetch('/__fws/snapshot/save', { method: 'POST' });
+    const snapshot = await snapRes.json();
+    expect(Object.keys(snapshot.gmail.messages).length).toBeGreaterThan(0);
+
+    // 3. Reset
+    await h.fetch('/__fws/reset', { method: 'POST' });
+
+    // 4. Verify reset to seed (5 seed messages, 5 seed files — the extras we added are gone)
+    const msgsRes = await h.fetch('/gmail/v1/users/me/messages');
+    const msgs = await msgsRes.json();
+    expect(msgs.messages.length).toBe(5); // only seed messages
+
+    const filesRes = await h.fetch('/drive/v3/files');
+    const files = await filesRes.json();
+    expect(files.files.length).toBe(5); // only seed files
+
+    // 5. Load snapshot
+    await h.fetch('/__fws/snapshot/load', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(snapshot),
+    });
+
+    // 6. Verify data restored (seed + our extras)
+    const msgsRes2 = await h.fetch('/gmail/v1/users/me/messages');
+    const msgs2 = await msgsRes2.json();
+    expect(msgs2.messages.length).toBeGreaterThan(5); // seed + added
+
+    const filesRes2 = await h.fetch('/drive/v3/files');
+    const files2 = await filesRes2.json();
+    expect(files2.files.length).toBeGreaterThan(5); // seed + added
+
+    // Verify via gws
+    const { stdout, exitCode } = await h.gws('gmail users messages list --params {"userId":"me"}');
+    expect(exitCode).toBe(0);
+    const gwsMsgs = JSON.parse(stdout);
+    expect(gwsMsgs.messages.length).toBeGreaterThan(0);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    testTimeout: 15000,
+    hookTimeout: 10000,
+  },
+});