mirror of
https://github.com/tiennm99/miti99bot.git
synced 2026-04-17 13:21:31 +00:00
feat(trading): add trade history and daily FIFO retention cron
- trading_trades table (migration 0001) persists every buy/sell via optional onTrade callback - /history [n] command shows caller's last N trades (default 10, max 50), HTML-escaped - daily cron at 0 17 * * * trims to 1000/user + 10000/global via FIFO delete - persistence failure logs but does not fail the trade reply
This commit is contained in:
345
tests/modules/trading/history.test.js
Normal file
345
tests/modules/trading/history.test.js
Normal file
@@ -0,0 +1,345 @@
|
||||
/**
|
||||
* @file Tests for trading/history — recordTrade, listTrades, formatTradesHtml,
|
||||
* createHistoryHandler, and buy/sell → D1 integration.
|
||||
*/
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { createSqlStore } from "../../../src/db/create-sql-store.js";
|
||||
import {
|
||||
createHistoryHandler,
|
||||
formatTradesHtml,
|
||||
listTrades,
|
||||
recordTrade,
|
||||
} from "../../../src/modules/trading/history.js";
|
||||
import { makeFakeD1 } from "../../fakes/fake-d1.js";
|
||||
|
||||
// ─── helpers ────────────────────────────────────────────────────────────────
|
||||
|
||||
/** Build a SqlStore backed by a fresh fake D1, pre-seeded with the table. */
|
||||
function makeTestSql() {
|
||||
const fakeDb = makeFakeD1();
|
||||
const sql = createSqlStore("trading", { DB: fakeDb });
|
||||
return { fakeDb, sql };
|
||||
}
|
||||
|
||||
/** Minimal grammY ctx double. */
|
||||
function makeCtx(match = "", userId = 123) {
|
||||
return {
|
||||
match,
|
||||
from: { id: userId },
|
||||
reply: vi.fn(),
|
||||
};
|
||||
}
|
||||
|
||||
/** A canned trade payload. */
|
||||
const TRADE = { userId: 1, symbol: "TCB", side: "buy", qty: 100, priceVnd: 25000 };
|
||||
|
||||
// ─── recordTrade ─────────────────────────────────────────────────────────────
|
||||
|
||||
describe("recordTrade", () => {
|
||||
it("inserts a row into trading_trades", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
await recordTrade(sql, TRADE);
|
||||
expect(fakeDb.runLog).toHaveLength(1);
|
||||
expect(fakeDb.runLog[0].query).toMatch(/INSERT INTO trading_trades/i);
|
||||
const binds = fakeDb.runLog[0].binds;
|
||||
expect(binds[0]).toBe(1); // user_id
|
||||
expect(binds[1]).toBe("TCB"); // symbol
|
||||
expect(binds[2]).toBe("buy"); // side
|
||||
expect(binds[3]).toBe(100); // qty
|
||||
expect(binds[4]).toBe(25000); // price_vnd
|
||||
expect(typeof binds[5]).toBe("number"); // ts
|
||||
});
|
||||
|
||||
it("logs a warning and returns silently when sql is null", async () => {
|
||||
const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
|
||||
await expect(recordTrade(null, TRADE)).resolves.toBeUndefined();
|
||||
expect(warn).toHaveBeenCalledWith(expect.stringContaining("no D1 binding"));
|
||||
warn.mockRestore();
|
||||
});
|
||||
|
||||
it("logs an error and does NOT throw when the insert fails", async () => {
|
||||
const fakeDb = makeFakeD1();
|
||||
// Make prepare().bind().run() throw.
|
||||
vi.spyOn(fakeDb, "prepare").mockReturnValue({
|
||||
bind: () => ({
|
||||
run: async () => {
|
||||
throw new Error("disk full");
|
||||
},
|
||||
}),
|
||||
});
|
||||
const sql = createSqlStore("trading", { DB: fakeDb });
|
||||
const error = vi.spyOn(console, "error").mockImplementation(() => {});
|
||||
await expect(recordTrade(sql, TRADE)).resolves.toBeUndefined();
|
||||
expect(error).toHaveBeenCalledWith(
|
||||
expect.stringContaining("recordTrade failed"),
|
||||
expect.any(Error),
|
||||
);
|
||||
error.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
// ─── listTrades ──────────────────────────────────────────────────────────────
|
||||
|
||||
describe("listTrades", () => {
|
||||
it("returns [] when sql is null", async () => {
|
||||
expect(await listTrades(null, 1, 10)).toEqual([]);
|
||||
});
|
||||
|
||||
it("returns [] when table is empty", async () => {
|
||||
const { sql } = makeTestSql();
|
||||
expect(await listTrades(sql, 1, 10)).toEqual([]);
|
||||
});
|
||||
|
||||
it("maps snake_case columns to camelCase Trade objects", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", [
|
||||
{ id: 1, user_id: 1, symbol: "TCB", side: "buy", qty: 10, price_vnd: 25000, ts: 1000 },
|
||||
]);
|
||||
const trades = await listTrades(sql, 1, 10);
|
||||
expect(trades).toHaveLength(1);
|
||||
expect(trades[0]).toMatchObject({
|
||||
id: 1,
|
||||
userId: 1,
|
||||
symbol: "TCB",
|
||||
side: "buy",
|
||||
qty: 10,
|
||||
priceVnd: 25000,
|
||||
ts: 1000,
|
||||
});
|
||||
});
|
||||
|
||||
it("clamps limit below 1 to 1", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", [
|
||||
{ id: 1, user_id: 1, symbol: "A", side: "buy", qty: 1, price_vnd: 100, ts: 1 },
|
||||
]);
|
||||
// Should not throw; clamps to 1 internally — binds[1] == 1.
|
||||
const trades = await listTrades(sql, 1, 0);
|
||||
// fake-d1 returns all seeded rows regardless of LIMIT bind, but we verify the bind.
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(1);
|
||||
});
|
||||
|
||||
it("clamps limit above 50 to 50", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
await listTrades(sql, 1, 999);
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(50);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── formatTradesHtml ────────────────────────────────────────────────────────
|
||||
|
||||
describe("formatTradesHtml", () => {
|
||||
it("returns fallback message for empty array", () => {
|
||||
expect(formatTradesHtml([])).toBe("No trades recorded yet.");
|
||||
});
|
||||
|
||||
it("HTML-escapes symbols containing special characters", () => {
|
||||
const trade = {
|
||||
id: 1,
|
||||
userId: 1,
|
||||
symbol: "<script>",
|
||||
side: "buy",
|
||||
qty: 1,
|
||||
priceVnd: 1000,
|
||||
ts: Date.now(),
|
||||
};
|
||||
const html = formatTradesHtml([trade]);
|
||||
expect(html).not.toContain("<script>");
|
||||
expect(html).toContain("<script>");
|
||||
});
|
||||
|
||||
it("renders BUY/SELL labels", () => {
|
||||
const buy = { id: 1, userId: 1, symbol: "TCB", side: "buy", qty: 10, priceVnd: 25000, ts: 0 };
|
||||
const sell = { id: 2, userId: 1, symbol: "TCB", side: "sell", qty: 5, priceVnd: 26000, ts: 1 };
|
||||
const html = formatTradesHtml([buy, sell]);
|
||||
expect(html).toContain("BUY");
|
||||
expect(html).toContain("SELL");
|
||||
});
|
||||
|
||||
it("includes quantity and symbol in output", () => {
|
||||
const trade = {
|
||||
id: 1,
|
||||
userId: 1,
|
||||
symbol: "VNM",
|
||||
side: "sell",
|
||||
qty: 50,
|
||||
priceVnd: 80000,
|
||||
ts: 0,
|
||||
};
|
||||
const html = formatTradesHtml([trade]);
|
||||
expect(html).toContain("50");
|
||||
expect(html).toContain("VNM");
|
||||
});
|
||||
});
|
||||
|
||||
// ─── createHistoryHandler ─────────────────────────────────────────────────────
|
||||
|
||||
describe("createHistoryHandler", () => {
|
||||
it("uses default 10 when match is empty", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
const handler = createHistoryHandler(sql);
|
||||
const ctx = makeCtx("", 1);
|
||||
await handler(ctx);
|
||||
// binds[1] should be 10 (the LIMIT bind)
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(10);
|
||||
expect(ctx.reply).toHaveBeenCalledOnce();
|
||||
});
|
||||
|
||||
it("passes parsed N to listTrades", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
const handler = createHistoryHandler(sql);
|
||||
const ctx = makeCtx("25", 1);
|
||||
await handler(ctx);
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(25);
|
||||
});
|
||||
|
||||
it("clamps N=999 to 50", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
const handler = createHistoryHandler(sql);
|
||||
const ctx = makeCtx("999", 1);
|
||||
await handler(ctx);
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(50);
|
||||
});
|
||||
|
||||
it("falls back to default 10 when N=0", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
const handler = createHistoryHandler(sql);
|
||||
const ctx = makeCtx("0", 1);
|
||||
await handler(ctx);
|
||||
expect(fakeDb.queryLog[0].binds[1]).toBe(10);
|
||||
});
|
||||
|
||||
it("replies with HTML parse_mode", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", []);
|
||||
const handler = createHistoryHandler(sql);
|
||||
const ctx = makeCtx("", 1);
|
||||
await handler(ctx);
|
||||
expect(ctx.reply).toHaveBeenCalledWith(expect.any(String), { parse_mode: "HTML" });
|
||||
});
|
||||
|
||||
it("works with sql=null — returns empty list message", async () => {
|
||||
const handler = createHistoryHandler(null);
|
||||
const ctx = makeCtx("", 1);
|
||||
await handler(ctx);
|
||||
expect(ctx.reply).toHaveBeenCalledWith("No trades recorded yet.", { parse_mode: "HTML" });
|
||||
});
|
||||
});
|
||||
|
||||
// ─── buy/sell → D1 integration ───────────────────────────────────────────────
|
||||
|
||||
describe("buy/sell handlers → recordTrade integration", () => {
|
||||
afterEach(() => vi.restoreAllMocks());
|
||||
|
||||
function stubFetch() {
|
||||
global.fetch = vi.fn((url) => {
|
||||
if (url.includes("tcbs")) {
|
||||
return Promise.resolve({
|
||||
ok: true,
|
||||
json: () => Promise.resolve({ data: [{ close: 25 }] }),
|
||||
});
|
||||
}
|
||||
if (url.includes("bidv")) {
|
||||
return Promise.resolve({
|
||||
ok: true,
|
||||
json: () =>
|
||||
Promise.resolve({ data: [{ currency: "USD", muaCk: "25,200", ban: "25,600" }] }),
|
||||
});
|
||||
}
|
||||
return Promise.reject(new Error(`unexpected fetch: ${url}`));
|
||||
});
|
||||
}
|
||||
|
||||
it("buy inserts a row into trading_trades", async () => {
|
||||
stubFetch();
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
const { createStore } = await import("../../../src/db/create-store.js");
|
||||
const { makeFakeKv } = await import("../../fakes/fake-kv-namespace.js");
|
||||
const { handleBuy } = await import("../../../src/modules/trading/handlers.js");
|
||||
const { savePortfolio, emptyPortfolio } = await import(
|
||||
"../../../src/modules/trading/portfolio.js"
|
||||
);
|
||||
|
||||
const db = createStore("trading", { KV: makeFakeKv() });
|
||||
const p = emptyPortfolio();
|
||||
p.currency.VND = 10_000_000;
|
||||
await savePortfolio(db, 42, p);
|
||||
|
||||
const onTrade = vi.fn(({ symbol, side, qty, priceVnd }) =>
|
||||
recordTrade(sql, { userId: 42, symbol, side, qty, priceVnd }),
|
||||
);
|
||||
const ctx = makeCtx("100 TCB", 42);
|
||||
await handleBuy(ctx, db, onTrade);
|
||||
|
||||
expect(onTrade).toHaveBeenCalledOnce();
|
||||
expect(fakeDb.runLog).toHaveLength(1);
|
||||
expect(fakeDb.runLog[0].binds[2]).toBe("buy");
|
||||
expect(fakeDb.runLog[0].binds[1]).toBe("TCB");
|
||||
});
|
||||
|
||||
it("sell inserts a row into trading_trades", async () => {
|
||||
stubFetch();
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
const { createStore } = await import("../../../src/db/create-store.js");
|
||||
const { makeFakeKv } = await import("../../fakes/fake-kv-namespace.js");
|
||||
const { handleSell } = await import("../../../src/modules/trading/handlers.js");
|
||||
const { savePortfolio, emptyPortfolio } = await import(
|
||||
"../../../src/modules/trading/portfolio.js"
|
||||
);
|
||||
|
||||
const db = createStore("trading", { KV: makeFakeKv() });
|
||||
const p = emptyPortfolio();
|
||||
p.assets.TCB = 200;
|
||||
await savePortfolio(db, 42, p);
|
||||
|
||||
const onTrade = vi.fn(({ symbol, side, qty, priceVnd }) =>
|
||||
recordTrade(sql, { userId: 42, symbol, side, qty, priceVnd }),
|
||||
);
|
||||
const ctx = makeCtx("50 TCB", 42);
|
||||
await handleSell(ctx, db, onTrade);
|
||||
|
||||
expect(onTrade).toHaveBeenCalledOnce();
|
||||
expect(fakeDb.runLog).toHaveLength(1);
|
||||
expect(fakeDb.runLog[0].binds[2]).toBe("sell");
|
||||
});
|
||||
|
||||
it("recordTrade failure does not prevent trade reply", async () => {
|
||||
stubFetch();
|
||||
const { sql } = makeTestSql();
|
||||
const { createStore } = await import("../../../src/db/create-store.js");
|
||||
const { makeFakeKv } = await import("../../fakes/fake-kv-namespace.js");
|
||||
const { handleBuy } = await import("../../../src/modules/trading/handlers.js");
|
||||
const { savePortfolio, emptyPortfolio } = await import(
|
||||
"../../../src/modules/trading/portfolio.js"
|
||||
);
|
||||
|
||||
const db = createStore("trading", { KV: makeFakeKv() });
|
||||
const p = emptyPortfolio();
|
||||
p.currency.VND = 10_000_000;
|
||||
await savePortfolio(db, 42, p);
|
||||
|
||||
// onTrade throws; trade reply must still succeed.
|
||||
const onTrade = async () => {
|
||||
throw new Error("D1 down");
|
||||
};
|
||||
const ctx = makeCtx("100 TCB", 42);
|
||||
|
||||
// handleBuy awaits onTrade directly; we wrap to absorb — mirrors real index.js
|
||||
// which calls recordTrade (which swallows). Here we test the swallow itself:
|
||||
const safeOnTrade = async (t) => {
|
||||
try {
|
||||
await onTrade(t);
|
||||
} catch {
|
||||
/* swallowed */
|
||||
}
|
||||
};
|
||||
await handleBuy(ctx, db, safeOnTrade);
|
||||
expect(ctx.reply).toHaveBeenCalledWith(expect.stringContaining("Bought"));
|
||||
});
|
||||
});
|
||||
195
tests/modules/trading/retention.test.js
Normal file
195
tests/modules/trading/retention.test.js
Normal file
@@ -0,0 +1,195 @@
|
||||
/**
|
||||
* @file Tests for trading/retention — trimTradesHandler per-user and global caps.
|
||||
*
|
||||
* Uses enhanced fake-d1 which supports:
|
||||
* - SELECT DISTINCT user_id
|
||||
* - SELECT id ... WHERE user_id = ? ORDER BY ts DESC LIMIT -1 OFFSET N
|
||||
* - SELECT id ... ORDER BY ts DESC LIMIT -1 OFFSET N
|
||||
* - DELETE FROM ... WHERE id IN (?, ...)
|
||||
*/
|
||||
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
import { createSqlStore } from "../../../src/db/create-sql-store.js";
|
||||
import { trimTradesHandler } from "../../../src/modules/trading/retention.js";
|
||||
import { makeFakeD1 } from "../../fakes/fake-d1.js";
|
||||
|
||||
// ─── helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
/** Build a fresh sql store backed by a new fake D1. */
|
||||
function makeTestSql() {
|
||||
const fakeDb = makeFakeD1();
|
||||
const sql = createSqlStore("trading", { DB: fakeDb });
|
||||
return { fakeDb, sql };
|
||||
}
|
||||
|
||||
/**
|
||||
* Build N trade rows for a given user_id.
|
||||
* ts increases from 1..N so that the LAST row (index N-1) has the highest ts
|
||||
* and is therefore the "newest".
|
||||
*
|
||||
* @param {number} userId
|
||||
* @param {number} count
|
||||
* @param {number} [idOffset=0] — added to each id to keep ids globally unique.
|
||||
* @returns {object[]}
|
||||
*/
|
||||
function makeTrades(userId, count, idOffset = 0) {
|
||||
return Array.from({ length: count }, (_, i) => ({
|
||||
id: idOffset + i + 1,
|
||||
user_id: userId,
|
||||
symbol: "TCB",
|
||||
side: "buy",
|
||||
qty: 1,
|
||||
price_vnd: 1000,
|
||||
ts: i + 1, // ts=1 is oldest, ts=count is newest
|
||||
}));
|
||||
}
|
||||
|
||||
/** Convenience: run trimTradesHandler with muted console output. */
|
||||
async function runTrim(sql, caps) {
|
||||
const spy = vi.spyOn(console, "log").mockImplementation(() => {});
|
||||
try {
|
||||
await trimTradesHandler({}, { sql }, caps);
|
||||
} finally {
|
||||
spy.mockRestore();
|
||||
}
|
||||
}
|
||||
|
||||
/** Return all rows remaining in trading_trades via the fake table map. */
|
||||
function allRows(fakeDb) {
|
||||
return fakeDb.tables.get("trading_trades") ?? [];
|
||||
}
|
||||
|
||||
// ─── sql=null guard ───────────────────────────────────────────────────────────
|
||||
|
||||
describe("trimTradesHandler — sql=null", () => {
|
||||
it("returns without throwing when sql is null", async () => {
|
||||
const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
|
||||
await expect(trimTradesHandler({}, { sql: null })).resolves.toBeUndefined();
|
||||
logSpy.mockRestore();
|
||||
});
|
||||
});
|
||||
|
||||
// ─── per-user trim ────────────────────────────────────────────────────────────
|
||||
|
||||
describe("trimTradesHandler — per-user trim", () => {
|
||||
it("removes rows beyond cap, keeping newest", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
// 5 trades for user 1, cap=3 → keeps ts=3,4,5 (newest 3), deletes ts=1,2.
|
||||
fakeDb.seed("trading_trades", makeTrades(1, 5));
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 1000 });
|
||||
|
||||
const remaining = allRows(fakeDb);
|
||||
expect(remaining).toHaveLength(3);
|
||||
// Remaining should be the 3 rows with highest ts.
|
||||
const tsSorted = remaining.map((r) => r.ts).sort((a, b) => b - a);
|
||||
expect(tsSorted).toEqual([5, 4, 3]);
|
||||
});
|
||||
|
||||
it("leaves users with rows <= cap untouched", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
// User 2 has 2 trades, cap=3 → none deleted.
|
||||
fakeDb.seed("trading_trades", makeTrades(2, 2));
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 1000 });
|
||||
|
||||
expect(allRows(fakeDb)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it("handles exactly cap rows — no deletion", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", makeTrades(1, 3));
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 1000 });
|
||||
|
||||
expect(allRows(fakeDb)).toHaveLength(3);
|
||||
});
|
||||
|
||||
it("trims multiple users independently", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
// User 1: 5 trades (cap 3 → keep 3). User 2: 2 trades (cap 3 → keep 2).
|
||||
fakeDb.seed("trading_trades", [...makeTrades(1, 5, 0), ...makeTrades(2, 2, 5)]);
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 1000 });
|
||||
|
||||
const remaining = allRows(fakeDb);
|
||||
// 3 from user1 + 2 from user2 = 5.
|
||||
expect(remaining).toHaveLength(5);
|
||||
const user1 = remaining.filter((r) => r.user_id === 1);
|
||||
const user2 = remaining.filter((r) => r.user_id === 2);
|
||||
expect(user1).toHaveLength(3);
|
||||
expect(user2).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── global FIFO trim ─────────────────────────────────────────────────────────
|
||||
|
||||
describe("trimTradesHandler — global trim", () => {
|
||||
it("keeps only globalCap newest rows across all users", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
// 15 trades total: user1=8, user2=7. globalCap=10 → keep 10 newest.
|
||||
const trades = [...makeTrades(1, 8, 0), ...makeTrades(2, 7, 8)];
|
||||
// Re-assign ts values to be globally unique so ordering is deterministic.
|
||||
trades.forEach((t, i) => {
|
||||
t.ts = i + 1;
|
||||
});
|
||||
fakeDb.seed("trading_trades", trades);
|
||||
|
||||
await runTrim(sql, { perUserCap: 1000, globalCap: 10 });
|
||||
|
||||
expect(allRows(fakeDb)).toHaveLength(10);
|
||||
// All remaining rows should have the top-10 ts values (6..15).
|
||||
const tsSorted = allRows(fakeDb)
|
||||
.map((r) => r.ts)
|
||||
.sort((a, b) => a - b);
|
||||
expect(tsSorted).toEqual([6, 7, 8, 9, 10, 11, 12, 13, 14, 15]);
|
||||
});
|
||||
|
||||
it("leaves rows untouched when count <= globalCap", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", makeTrades(1, 5));
|
||||
|
||||
await runTrim(sql, { perUserCap: 1000, globalCap: 10 });
|
||||
|
||||
expect(allRows(fakeDb)).toHaveLength(5);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── combined pass ────────────────────────────────────────────────────────────
|
||||
|
||||
describe("trimTradesHandler — combined per-user + global", () => {
|
||||
it("applies per-user first, then global", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
// User 1: 6 trades (perUserCap=4 → trim to 4).
|
||||
// User 2: 6 trades (perUserCap=4 → trim to 4).
|
||||
// After per-user: 8 rows total.
|
||||
// globalCap=6 → trim to 6.
|
||||
const trades = [...makeTrades(1, 6, 0), ...makeTrades(2, 6, 6)];
|
||||
// Assign globally monotone ts values.
|
||||
trades.forEach((t, i) => {
|
||||
t.ts = i + 1;
|
||||
});
|
||||
fakeDb.seed("trading_trades", trades);
|
||||
|
||||
await runTrim(sql, { perUserCap: 4, globalCap: 6 });
|
||||
|
||||
expect(allRows(fakeDb)).toHaveLength(6);
|
||||
});
|
||||
});
|
||||
|
||||
// ─── idempotence ──────────────────────────────────────────────────────────────
|
||||
|
||||
describe("trimTradesHandler — idempotence", () => {
|
||||
it("second run is a no-op when already within caps", async () => {
|
||||
const { fakeDb, sql } = makeTestSql();
|
||||
fakeDb.seed("trading_trades", makeTrades(1, 5));
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 10 });
|
||||
const afterFirst = allRows(fakeDb).length;
|
||||
|
||||
await runTrim(sql, { perUserCap: 3, globalCap: 10 });
|
||||
const afterSecond = allRows(fakeDb).length;
|
||||
|
||||
expect(afterFirst).toBe(afterSecond);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user