freelang-editor 11.7.4

package/src/__tests__/stdlib-mongodb.test.ts

@@ -0,0 +1,331 @@
+// Test suite for MongoDB stdlib
+// Phase 1: BSON roundtrip tests
+
+// jest globals — describe/it/expect/beforeAll/afterAll 자동 제공 (import 불필요)
+
+// Import BSON functions (need to extract these from stdlib-mongodb.ts)
+// For now, we'll implement inline test versions
+
+// BSON Type codes
+const BsonType = {
+  Double: 0x01,
+  String: 0x02,
+  Document: 0x03,
+  Array: 0x04,
+  Boolean: 0x08,
+  Null: 0x0a,
+  Int32: 0x10,
+  Timestamp: 0x11,
+  Int64: 0x12,
+  ObjectId: 0x07,
+};
+
+// Copy BSON encoder/decoder from stdlib-mongodb.ts inline for testing
+function encodeBson(doc: Record<string, any>): Buffer {
+  const parts: Buffer[] = [];
+
+  for (const [key, val] of Object.entries(doc)) {
+    parts.push(encodeElement(key, val));
+  }
+
+  const body = Buffer.concat(parts);
+  const totalLen = 4 + body.length + 1;
+
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeInt32LE(totalLen, 0);
+
+  return Buffer.concat([lenBuf, body, Buffer.from([0x00])]);
+}
+
+function encodeElement(key: string, val: any): Buffer {
+  const keyBuf = Buffer.from(key + "\0", "utf-8");
+
+  if (val === null) {
+    return Buffer.concat([Buffer.from([BsonType.Null]), keyBuf]);
+  }
+
+  if (typeof val === "boolean") {
+    return Buffer.concat([
+      Buffer.from([BsonType.Boolean]),
+      keyBuf,
+      Buffer.from([val ? 1 : 0]),
+    ]);
+  }
+
+  if (typeof val === "number") {
+    if (Number.isInteger(val) && Math.abs(val) <= 2147483647) {
+      const buf = Buffer.alloc(4);
+      buf.writeInt32LE(val, 0);
+      return Buffer.concat([Buffer.from([BsonType.Int32]), keyBuf, buf]);
+    } else {
+      const buf = Buffer.alloc(8);
+      buf.writeDoubleLE(val, 0);
+      return Buffer.concat([Buffer.from([BsonType.Double]), keyBuf, buf]);
+    }
+  }
+
+  if (typeof val === "string") {
+    const strBuf = Buffer.from(val + "\0", "utf-8");
+    const lenBuf = Buffer.alloc(4);
+    lenBuf.writeInt32LE(strBuf.length, 0);
+    return Buffer.concat([
+      Buffer.from([BsonType.String]),
+      keyBuf,
+      lenBuf,
+      strBuf,
+    ]);
+  }
+
+  if (Array.isArray(val)) {
+    const arrObj: Record<string, any> = {};
+    val.forEach((v, i) => {
+      arrObj[i.toString()] = v;
+    });
+    const docBuf = encodeBson(arrObj);
+    return Buffer.concat([Buffer.from([BsonType.Array]), keyBuf, docBuf]);
+  }
+
+  if (typeof val === "object") {
+    const docBuf = encodeBson(val);
+    return Buffer.concat([Buffer.from([BsonType.Document]), keyBuf, docBuf]);
+  }
+
+  const strBuf = Buffer.from(String(val) + "\0", "utf-8");
+  const lenBuf = Buffer.alloc(4);
+  lenBuf.writeInt32LE(strBuf.length, 0);
+  return Buffer.concat([
+    Buffer.from([BsonType.String]),
+    keyBuf,
+    lenBuf,
+    strBuf,
+  ]);
+}
+
+function decodeBson(buf: Buffer): Record<string, any> {
+  const result: Record<string, any> = {};
+
+  const docLen = buf.readInt32LE(0);
+  if (buf.length < docLen) {
+    throw new Error(`BSON buffer too short: ${buf.length} < ${docLen}`);
+  }
+
+  let offset = 4;
+  const endOffset = docLen - 1;
+
+  while (offset < endOffset) {
+    const { key, value, consumed } = decodeElement(buf, offset);
+    result[key] = value;
+    offset += consumed;
+  }
+
+  return result;
+}
+
+function decodeElement(
+  buf: Buffer,
+  offset: number
+): { key: string; value: any; consumed: number } {
+  const typeByte = buf[offset];
+  offset += 1;
+
+  let keyEnd = offset;
+  while (buf[keyEnd] !== 0) keyEnd++;
+  const key = buf.toString("utf-8", offset, keyEnd);
+  offset = keyEnd + 1;
+
+  let consumed = 1;
+  consumed += key.length + 1;
+
+  switch (typeByte) {
+    case BsonType.Null:
+      return { key, value: null, consumed };
+
+    case BsonType.Boolean:
+      const bool = buf[offset] !== 0;
+      return { key, value: bool, consumed: consumed + 1 };
+
+    case BsonType.Int32: {
+      const val = buf.readInt32LE(offset);
+      return { key, value: val, consumed: consumed + 4 };
+    }
+
+    case BsonType.Double: {
+      const val = buf.readDoubleLE(offset);
+      return { key, value: val, consumed: consumed + 8 };
+    }
+
+    case BsonType.String: {
+      const len = buf.readInt32LE(offset);
+      const val = buf.toString("utf-8", offset + 4, offset + 4 + len - 1);
+      return { key, value: val, consumed: consumed + 4 + len };
+    }
+
+    case BsonType.Array:
+    case BsonType.Document: {
+      const len = buf.readInt32LE(offset);
+      const docBuf = buf.subarray(offset, offset + len);
+      const val = decodeBson(docBuf);
+      if (typeByte === BsonType.Array) {
+        return {
+          key,
+          value: Object.keys(val)
+            .sort((a, b) => parseInt(a) - parseInt(b))
+            .map((k) => val[k]),
+          consumed: consumed + len,
+        };
+      }
+      return { key, value: val, consumed: consumed + len };
+    }
+
+    case BsonType.Int64: {
+      const val = buf.readBigInt64LE(offset);
+      return { key, value: Number(val), consumed: consumed + 8 };
+    }
+
+    case BsonType.Timestamp: {
+      const val = buf.readBigUInt64LE(offset);
+      return { key, value: Number(val), consumed: consumed + 8 };
+    }
+
+    default:
+      throw new Error(`Unknown BSON type: 0x${typeByte.toString(16)}`);
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────
+
+describe("BSON Roundtrip Tests (Phase 1)", () => {
+  it("should encode/decode null", () => {
+    const doc = { value: null };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.value).toBeNull();
+  });
+
+  it("should encode/decode boolean true", () => {
+    const doc = { flag: true };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.flag).toBe(true);
+  });
+
+  it("should encode/decode boolean false", () => {
+    const doc = { flag: false };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.flag).toBe(false);
+  });
+
+  it("should encode/decode Int32", () => {
+    const doc = { count: 42 };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.count).toBe(42);
+  });
+
+  it("should encode/decode Double", () => {
+    const doc = { price: 19.99 };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(Math.abs(decoded.price - 19.99) < 0.001).toBe(true);
+  });
+
+  it("should encode/decode String", () => {
+    const doc = { name: "alice" };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.name).toBe("alice");
+  });
+
+  it("should encode/decode Document (nested object)", () => {
+    const doc = {
+      user: {
+        id: 1,
+        name: "bob",
+      },
+    };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.user.id).toBe(1);
+    expect(decoded.user.name).toBe("bob");
+  });
+
+  it("should encode/decode Array", () => {
+    const doc = {
+      tags: ["a", "b", "c"],
+    };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.tags).toEqual(["a", "b", "c"]);
+  });
+
+  it("should encode/decode mixed types", () => {
+    const doc = {
+      _id: "123",
+      name: "test",
+      age: 30,
+      score: 95.5,
+      active: true,
+      meta: null,
+      tags: ["t1", "t2"],
+      nested: {
+        key: "value",
+      },
+    };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+
+    expect(decoded._id).toBe("123");
+    expect(decoded.name).toBe("test");
+    expect(decoded.age).toBe(30);
+    expect(Math.abs(decoded.score - 95.5) < 0.001).toBe(true);
+    expect(decoded.active).toBe(true);
+    expect(decoded.meta).toBeNull();
+    expect(decoded.tags).toEqual(["t1", "t2"]);
+    expect(decoded.nested.key).toBe("value");
+  });
+
+  it("should handle large Int32 values", () => {
+    const doc = { big: 2147483647 }; // Max Int32
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.big).toBe(2147483647);
+  });
+
+  it("should handle negative numbers", () => {
+    const doc = { neg: -42 };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.neg).toBe(-42);
+  });
+
+  it("should handle empty object", () => {
+    const doc = {};
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(Object.keys(decoded).length).toBe(0);
+  });
+
+  it("should handle empty array", () => {
+    const doc = { arr: [] };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.arr).toEqual([]);
+  });
+
+  it("should handle UTF-8 strings", () => {
+    const doc = { text: "안녕하세요" };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.text).toBe("안녕하세요");
+  });
+
+  it("should handle special characters in strings", () => {
+    const doc = { special: 'test"with\'quotes' };
+    const encoded = encodeBson(doc);
+    const decoded = decodeBson(encoded);
+    expect(decoded.special).toBe('test"with\'quotes');
+  });
+});

package/src/__tests__/stdlib-new.test.ts

@@ -0,0 +1,269 @@
+import * as fs from 'fs';
+import { Interpreter } from '../interpreter';
+import { lex } from '../lexer';
+import { Parser } from '../parser';
+
+function run(src: string): any {
+  const tokens = lex(src);
+  const ast = new Parser(tokens).parse();
+  const interp = new Interpreter();
+  interp.interpret(ast);
+  return (interp as any).context?.lastValue ?? null;
+}
+
+function loadLib(name: string): string {
+  return fs.readFileSync(`stdlib/${name}.fl`, 'utf8');
+}
+
+beforeAll(() => { jest.spyOn(console, 'log').mockImplementation(() => {}); });
+afterAll(() => { jest.restoreAllMocks(); });
+
+// ─── cache.fl ────────────────────────────────────────────────────────────────
+describe("stdlib/cache.fl", () => {
+  const src = loadLib('cache');
+
+  test("cache-create returns a cache handle", () => {
+    const r = run(src + '\n(define ch (cache-create 10)) (type-of ch)');
+    expect(r).toBe('map');
+  });
+
+  test("cache-set / cache-get round-trip", () => {
+    const r = run(src + '\n(define ch (cache-create 10)) (cache-set ch "k" 42) (cache-get ch "k")');
+    expect(r).toBe(42);
+  });
+
+  test("cache-get returns nil for missing key", () => {
+    const r = run(src + '\n(define ch (cache-create 10)) (cache-get ch "missing")');
+    expect(r).toBeNull();
+  });
+
+  test("cache-has: existing key", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-set ch "x" 1)
+(cache-has ch "x")`);
+    expect(r).toBe(true);
+  });
+
+  test("cache-has: missing key", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-has ch "missing")`);
+    expect(r).toBe(false);
+  });
+
+  test("cache-del removes key", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-set ch "k" 99)
+(cache-del ch "k")
+(cache-has ch "k")`);
+    expect(r).toBe(false);
+  });
+
+  test("cache-clear clears all", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-set ch "a" 1) (cache-set ch "b" 2)
+(cache-clear ch)
+(cache-stats ch)`);
+    expect((r as any).size).toBe(0);
+  });
+
+  test("cache-stats returns hit-rate", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-set ch "k" 1)
+(cache-get ch "k")
+(cache-get ch "k")
+(cache-get ch "missing")
+(cache-stats ch)`);
+    expect((r as any).hits).toBe(2);
+    expect((r as any).misses).toBe(1);
+    expect((r as any)['hit-rate']).toBeCloseTo(2/3);
+  });
+
+  test("LRU eviction: oldest key removed when full", () => {
+    const aEvicted = run(src + `
+(define ch (cache-create 3))
+(cache-set ch "a" 1)
+(cache-set ch "b" 2)
+(cache-set ch "c" 3)
+(cache-set ch "d" 4)
+(cache-has ch "a")`);
+    const dPresent = run(src + `
+(define ch (cache-create 3))
+(cache-set ch "a" 1)
+(cache-set ch "b" 2)
+(cache-set ch "c" 3)
+(cache-set ch "d" 4)
+(cache-has ch "d")`);
+    expect(aEvicted).toBe(false);
+    expect(dPresent).toBe(true);
+  });
+
+  test("cache-get-or-set only calls fn once on repeated access", () => {
+    const val = run(src + `
+(define ch (cache-create 10))
+(defn compute [] 99)
+(cache-get-or-set ch "k" compute)
+(cache-get-or-set ch "k" compute)`);
+    expect(val).toBe(99);
+  });
+
+  test("cache-get-or-set stores value on first call", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-get-or-set ch "k" (fn [] 42))
+(cache-get ch "k")`);
+    expect(r).toBe(42);
+  });
+
+  test("cache-get-or-set-ttl stores with TTL", () => {
+    const r = run(src + `
+(define ch (cache-create 10))
+(cache-get-or-set-ttl ch "k" 60000 (fn [] "hello"))
+(cache-get ch "k")`);
+    expect(r).toBe('hello');
+  });
+
+  test("make-cache creates cache with given size", () => {
+    const stats = run(src + `
+(define ch (make-cache 50))
+(cache-stats ch)`);
+    expect((stats as any).size).toBe(0);
+  });
+});
+
+// ─── validate.fl ─────────────────────────────────────────────────────────────
+describe("stdlib/validate.fl", () => {
+  const src = loadLib('validate');
+
+  test("validate-email: valid", () => {
+    expect(run(src + '\n(validate-email "a@b.com")')).toBe(true);
+    expect(run(src + '\n(validate-email "user.name+tag@example.co.uk")')).toBe(true);
+  });
+
+  test("validate-email: invalid", () => {
+    expect(run(src + '\n(validate-email "notanemail")')).toBe(false);
+    expect(run(src + '\n(validate-email "@b.com")')).toBe(false);
+    expect(run(src + '\n(validate-email nil)')).toBe(false);
+  });
+
+  test("validate-url: valid", () => {
+    expect(run(src + '\n(validate-url "https://example.com")')).toBe(true);
+    expect(run(src + '\n(validate-url "http://localhost:3000")')).toBe(true);
+  });
+
+  test("validate-url: invalid", () => {
+    expect(run(src + '\n(validate-url "ftp://x.com")')).toBe(false);
+    expect(run(src + '\n(validate-url "not-a-url")')).toBe(false);
+  });
+
+  test("validate-min-length / validate-max-length", () => {
+    expect(run(src + '\n(validate-min-length "hello" 3)')).toBe(true);
+    expect(run(src + '\n(validate-min-length "hi" 5)')).toBe(false);
+    expect(run(src + '\n(validate-max-length "hi" 5)')).toBe(true);
+    expect(run(src + '\n(validate-max-length "hello world" 5)')).toBe(false);
+  });
+
+  test("validate-range", () => {
+    expect(run(src + '\n(validate-range 3 1 10)')).toBe(true);
+    expect(run(src + '\n(validate-range 0 1 10)')).toBe(false);
+    expect(run(src + '\n(validate-range 10 1 10)')).toBe(true);
+  });
+
+  test("validate-integer / validate-positive / validate-non-negative", () => {
+    expect(run(src + '\n(validate-integer 5)')).toBe(true);
+    expect(run(src + '\n(validate-integer 5.5)')).toBe(false);
+    expect(run(src + '\n(validate-positive 1)')).toBe(true);
+    expect(run(src + '\n(validate-positive -1)')).toBe(false);
+    expect(run(src + '\n(validate-non-negative 0)')).toBe(true);
+  });
+
+  test("validate-required returns empty array when all ok", () => {
+    const r = run(src + `
+(validate-required {:name "Kim" :age 30} ["name" "age"])`);
+    expect(r).toEqual([]);
+  });
+
+  test("validate-required detects nil and blank fields", () => {
+    const r = run(src + `
+(validate-required {:name "" :age nil :email "x@y.com"} ["name" "age" "email"])`);
+    expect((r as string[]).sort()).toEqual(['age', 'name']);
+  });
+
+  test("validate-schema: all valid", () => {
+    const r = run(src + `
+(validate-schema
+  {:name "Kim" :age 30 :email "a@b.com"}
+  {:name {:required true :min-length 2}
+   :age  {:type "number" :min 0 :max 150}
+   :email {:required true :email true}})`);
+    expect((r as any).ok).toBe(true);
+    expect((r as any).errors).toHaveLength(0);
+  });
+
+  test("validate-schema: catches errors", () => {
+    const r = run(src + `
+(validate-schema
+  {:name "" :age 200 :email "notvalid"}
+  {:name {:required true :min-length 2}
+   :age  {:type "number" :max 150}
+   :email {:email true}})`);
+    expect((r as any).ok).toBe(false);
+    expect((r as any).errors.length).toBeGreaterThan(0);
+  });
+});
+
+// ─── log.fl ──────────────────────────────────────────────────────────────────
+describe("stdlib/log.fl", () => {
+  const src = loadLib('log');
+
+  function captureLog(code: string): any[] {
+    const captured: string[] = [];
+    let buf = '';
+    const orig = process.stdout.write.bind(process.stdout);
+    (process.stdout as any).write = (chunk: any) => {
+      buf += String(chunk);
+      const lines = buf.split('\n');
+      buf = lines.pop() ?? '';
+      lines.forEach(l => { if (l.trim()) captured.push(l.trim()); });
+    };
+    try { run(src + '\n' + code); } finally { (process.stdout as any).write = orig; }
+    if (buf.trim()) captured.push(buf.trim());
+    return captured.map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  }
+
+  test("log-info outputs INFO level JSON", () => {
+    const logs = captureLog('(log-info "user.login" {:userId 1})');
+    expect(logs.length).toBeGreaterThan(0);
+    expect(logs[logs.length - 1].level).toBe('INFO');
+    expect(logs[logs.length - 1].event).toBe('user.login');
+  });
+
+  test("log-warn outputs WARN level", () => {
+    const logs = captureLog('(log-warn "rate.limit" {:current 90})');
+    expect(logs[logs.length - 1].level).toBe('WARN');
+  });
+
+  test("log-error outputs ERROR level with ctx", () => {
+    const logs = captureLog('(log-error "db.fail" {:err "timeout"})');
+    const last = logs[logs.length - 1];
+    expect(last.level).toBe('ERROR');
+    expect(last.ctx.err).toBe('timeout');
+  });
+
+  test("log-debug suppressed without FL_DEBUG=1", () => {
+    const logs = captureLog('(log-debug "cache.miss" {:key "x"})');
+    const debugLogs = logs.filter((l: any) => l?.level === 'DEBUG');
+    expect(debugLogs.length).toBe(0);
+  });
+
+  test("log entry includes ts and event", () => {
+    const logs = captureLog('(log-info "test.event" {:x 1})');
+    const last = logs[logs.length - 1];
+    expect(typeof last.ts).toBe('number');
+    expect(last.event).toBe('test.event');
+  });
+});