gate option print clickhouse persistence by signal pass

services/ingest-options/tests/trade-pipeline.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "bun:test";
+import type { OptionPrint } from "@islandflow/types";
+import { processOptionTrade, shouldPersistOptionPrint } from "../src/trade-pipeline";
+
+const makePrint = (signalPass: boolean): OptionPrint => ({
+  source_ts: 1_000,
+  ingest_ts: 1_001,
+  seq: 1,
+  trace_id: `print-${signalPass ? "pass" : "fail"}`,
+  ts: 1_000,
+  option_contract_id: "SPY-2025-01-17-450-C",
+  price: 1.25,
+  size: 100,
+  exchange: "TEST",
+  signal_pass: signalPass
+});
+
+describe("option trade persistence gating", () => {
+  it("does not persist failing prints when signal-only persistence is enabled", async () => {
+    const persisted: string[] = [];
+    const rawPublished: string[] = [];
+    const signalPublished: string[] = [];
+
+    await processOptionTrade(makePrint(false), {
+      persistSignalOnly: true,
+      persist: async (print) => {
+        persisted.push(print.trace_id);
+      },
+      publishRaw: async (print) => {
+        rawPublished.push(print.trace_id);
+      },
+      publishSignal: async (print) => {
+        signalPublished.push(print.trace_id);
+      }
+    });
+
+    expect(persisted).toEqual([]);
+    expect(rawPublished).toEqual(["print-fail"]);
+    expect(signalPublished).toEqual([]);
+  });
+
+  it("persists and publishes passing prints when signal-only persistence is enabled", async () => {
+    const persisted: string[] = [];
+    const rawPublished: string[] = [];
+    const signalPublished: string[] = [];
+
+    await processOptionTrade(makePrint(true), {
+      persistSignalOnly: true,
+      persist: async (print) => {
+        persisted.push(print.trace_id);
+      },
+      publishRaw: async (print) => {
+        rawPublished.push(print.trace_id);
+      },
+      publishSignal: async (print) => {
+        signalPublished.push(print.trace_id);
+      }
+    });
+
+    expect(persisted).toEqual(["print-pass"]);
+    expect(rawPublished).toEqual(["print-pass"]);
+    expect(signalPublished).toEqual(["print-pass"]);
+  });
+
+  it("persists failing prints when signal-only persistence is disabled", async () => {
+    const persisted: string[] = [];
+    const rawPublished: string[] = [];
+    const signalPublished: string[] = [];
+
+    await processOptionTrade(makePrint(false), {
+      persistSignalOnly: false,
+      persist: async (print) => {
+        persisted.push(print.trace_id);
+      },
+      publishRaw: async (print) => {
+        rawPublished.push(print.trace_id);
+      },
+      publishSignal: async (print) => {
+        signalPublished.push(print.trace_id);
+      }
+    });
+
+    expect(persisted).toEqual(["print-fail"]);
+    expect(rawPublished).toEqual(["print-fail"]);
+    expect(signalPublished).toEqual([]);
+  });
+});
+
+describe("shouldPersistOptionPrint", () => {
+  it("returns true for passing prints in signal-only mode", () => {
+    expect(shouldPersistOptionPrint({ signal_pass: true }, true)).toBe(true);
+  });
+
+  it("returns false for failing prints in signal-only mode", () => {
+    expect(shouldPersistOptionPrint({ signal_pass: false }, true)).toBe(false);
+  });
+
+  it("returns true for failing prints when signal-only mode is disabled", () => {
+    expect(shouldPersistOptionPrint({ signal_pass: false }, false)).toBe(true);
+  });
+});