feat: 完成测试 16-17

src/utils/__tests__/bufferedWriter.test.ts

@@ -0,0 +1,117 @@
+import { describe, expect, test } from "bun:test";
+import { createBufferedWriter } from "../bufferedWriter";
+
+describe("createBufferedWriter", () => {
+  test("immediateMode calls writeFn directly", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+      immediateMode: true,
+    });
+    writer.write("a");
+    writer.write("b");
+    expect(written).toEqual(["a", "b"]);
+  });
+
+  test("buffered mode accumulates until flush", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+    });
+    writer.write("hello ");
+    writer.write("world");
+    expect(written).toEqual([]);
+    writer.flush();
+    expect(written).toEqual(["hello world"]);
+  });
+
+  test("flush with empty buffer does not call writeFn", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+    });
+    writer.flush();
+    expect(written).toEqual([]);
+  });
+
+  test("flush clears the buffer", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+    });
+    writer.write("data");
+    writer.flush();
+    writer.flush(); // second flush should be no-op
+    expect(written).toEqual(["data"]);
+  });
+
+  test("overflow triggers deferred flush when maxBufferSize reached", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+      maxBufferSize: 2,
+    });
+    writer.write("a");
+    writer.write("b");
+    // 2 writes = maxBufferSize, triggers flushDeferred via setImmediate
+    expect(written).toEqual([]);
+  });
+
+  test("overflow triggers deferred flush when maxBufferBytes reached", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+      maxBufferBytes: 5,
+    });
+    writer.write("abc");
+    writer.write("def");
+    // total 6 bytes > 5, triggers flushDeferred
+    expect(written).toEqual([]);
+  });
+
+  test("dispose flushes remaining buffer", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+    });
+    writer.write("final");
+    writer.dispose();
+    expect(written).toEqual(["final"]);
+  });
+
+  test("dispose flushes pending overflow", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+      maxBufferSize: 1,
+    });
+    writer.write("overflow-data");
+    // overflow triggered but deferred; dispose should flush it synchronously
+    writer.dispose();
+    expect(written).toEqual(["overflow-data"]);
+  });
+
+  test("coalesced overflow — multiple overflows merge before write", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+      maxBufferSize: 1,
+    });
+    writer.write("a"); // triggers first overflow (deferred)
+    writer.write("b"); // pendingOverflow exists, coalesces
+    writer.dispose();   // flushes coalesced overflow
+    expect(written).toEqual(["ab"]);
+  });
+
+  test("multiple flushes produce concatenated writes", () => {
+    const written: string[] = [];
+    const writer = createBufferedWriter({
+      writeFn: (c) => written.push(c),
+    });
+    writer.write("batch1");
+    writer.flush();
+    writer.write("batch2");
+    writer.flush();
+    expect(written).toEqual(["batch1", "batch2"]);
+  });
+});