jinaga-server 3.7.5 → 3.8.1

package/test/jinaga-server/tracePoolSpec.ts

@@ -0,0 +1,368 @@
+import { EventEmitter } from "events";
+import { Trace, Tracer } from "jinaga";
+import { Pool } from "pg";
+
+import { tracePool } from "../../src/jinaga-server";
+
+const windowMilliseconds = 10000;
+
+// Jest's own fake timers cannot be installed on this version of Node, because
+// they try to replace the read-only global `performance`. These stand in for
+// the interval timer alone, which is all tracePool schedules, and they record
+// whether it was unreferenced and whether it was cleared.
+class FakeInterval {
+    public dueAt: number;
+    public cleared = false;
+    private referenced = true;
+
+    constructor(
+        private readonly callback: () => void,
+        public readonly delay: number,
+        now: number
+    ) {
+        this.dueAt = now + delay;
+    }
+
+    ref(): this {
+        this.referenced = true;
+        return this;
+    }
+
+    unref(): this {
+        this.referenced = false;
+        return this;
+    }
+
+    hasRef(): boolean {
+        return this.referenced;
+    }
+
+    fire() {
+        this.callback();
+    }
+}
+
+class FakeClock {
+    private now = 0;
+    private readonly created: FakeInterval[] = [];
+
+    install() {
+        jest.spyOn(global, 'setInterval').mockImplementation(((callback: () => void, delay?: number) => {
+            const interval = new FakeInterval(callback, delay ?? 0, this.now);
+            this.created.push(interval);
+            return interval;
+        }) as any);
+        jest.spyOn(global, 'clearInterval').mockImplementation(((handle: FakeInterval) => {
+            handle.cleared = true;
+        }) as any);
+    }
+
+    advance(milliseconds: number) {
+        const end = this.now + milliseconds;
+        for (;;) {
+            const due = this.live()
+                .filter(interval => interval.dueAt <= end)
+                .sort((a, b) => a.dueAt - b.dueAt)[0];
+            if (!due) {
+                break;
+            }
+            this.now = due.dueAt;
+            due.dueAt = this.now + due.delay;
+            due.fire();
+        }
+        this.now = end;
+    }
+
+    live(): FakeInterval[] {
+        return this.created.filter(interval => !interval.cleared);
+    }
+
+    only(): FakeInterval {
+        expect(this.created).toHaveLength(1);
+        return this.created[0];
+    }
+}
+
+interface Counts {
+    total: number;
+    idle: number;
+    waiting: number;
+}
+
+interface MetricLine {
+    message: string;
+    measurements: { [key: string]: number };
+}
+
+class RecordingTracer implements Tracer {
+    public readonly info_: string[] = [];
+    public readonly warnings: string[] = [];
+    public readonly errors: any[] = [];
+    public readonly metrics: MetricLine[] = [];
+
+    info(message: string): void {
+        this.info_.push(message);
+    }
+
+    warn(message: string): void {
+        this.warnings.push(message);
+    }
+
+    error(error: any): void {
+        this.errors.push(error);
+    }
+
+    dependency<T>(name: string, data: string, operation: () => Promise<T>): Promise<T> {
+        return operation();
+    }
+
+    metric(message: string, measurements: { [key: string]: number }): void {
+        this.metrics.push({ message, measurements });
+    }
+
+    counter(name: string, value: number): void {
+    }
+
+    linesNamed(message: string): MetricLine[] {
+        return this.metrics.filter(m => m.message === message);
+    }
+}
+
+// Stands in for a pg Pool. It reports the counts a test chooses and emits the
+// events a real pool emits, so tracePool can be driven through a storm without
+// a database.
+class PoolDouble extends EventEmitter {
+    public totalCount = 0;
+    public idleCount = 0;
+    public waitingCount = 0;
+    public ended = false;
+
+    asPool(): Pool {
+        return this as unknown as Pool;
+    }
+
+    acquire(counts: Counts) {
+        this.report(counts);
+        this.emit('acquire', {});
+    }
+
+    release(counts: Counts) {
+        this.report(counts);
+        this.emit('release', undefined, {});
+    }
+
+    connect(counts: Counts) {
+        this.report(counts);
+        this.emit('connect', {});
+    }
+
+    remove(counts: Counts) {
+        this.report(counts);
+        this.emit('remove', {});
+    }
+
+    fail(error: Error) {
+        this.emit('error', error, {});
+    }
+
+    private report(counts: Counts) {
+        this.totalCount = counts.total;
+        this.idleCount = counts.idle;
+        this.waitingCount = counts.waiting;
+    }
+}
+
+describe('tracePool', () => {
+    let tracer: RecordingTracer;
+    let pool: PoolDouble;
+    let clock: FakeClock;
+
+    beforeEach(() => {
+        clock = new FakeClock();
+        clock.install();
+        tracer = new RecordingTracer();
+        Trace.configure(tracer);
+        pool = new PoolDouble();
+    });
+
+    afterEach(() => {
+        jest.restoreAllMocks();
+        Trace.off();
+    });
+
+    it('should write one line for a window of a thousand acquires', () => {
+        tracePool(pool.asPool());
+
+        for (let i = 0; i < 1000; i++) {
+            pool.acquire({ total: 10, idle: 0, waiting: 0 });
+            pool.release({ total: 10, idle: 1, waiting: 0 });
+        }
+
+        expect(tracer.metrics).toHaveLength(0);
+
+        clock.advance(windowMilliseconds);
+
+        expect(tracer.linesNamed('Postgres pool')).toHaveLength(1);
+        expect(tracer.metrics).toHaveLength(1);
+    });
+
+    it('should write no line per acquire', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 0, waiting: 0 });
+        pool.acquire({ total: 10, idle: 0, waiting: 1 });
+
+        expect(tracer.metrics).toHaveLength(0);
+        expect(tracer.linesNamed('Postgres acquired')).toHaveLength(0);
+
+        clock.advance(windowMilliseconds);
+
+        expect(tracer.linesNamed('Postgres acquired')).toHaveLength(0);
+    });
+
+    it('should carry the peak waiting count of a spike that came and went', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 0, waiting: 0 });
+        pool.acquire({ total: 10, idle: 0, waiting: 349 });
+        pool.release({ total: 10, idle: 0, waiting: 120 });
+        pool.release({ total: 10, idle: 3, waiting: 0 });
+
+        clock.advance(windowMilliseconds);
+
+        const lines = tracer.linesNamed('Postgres pool');
+        expect(lines).toHaveLength(1);
+        expect(lines[0].measurements).toEqual({
+            total: 10,
+            idle: 3,
+            waiting: 0,
+            peakWaiting: 349
+        });
+    });
+
+    it('should warn about a window whose peak waiting count was above zero', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 0, waiting: 349 });
+        pool.release({ total: 10, idle: 3, waiting: 0 });
+
+        clock.advance(windowMilliseconds);
+
+        expect(tracer.warnings).toHaveLength(1);
+        expect(tracer.warnings[0]).toContain('349');
+    });
+
+    it('should not warn about a window that never had a request waiting', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 2, waiting: 0 });
+
+        clock.advance(windowMilliseconds);
+
+        expect(tracer.linesNamed('Postgres pool')).toHaveLength(1);
+        expect(tracer.warnings).toHaveLength(0);
+    });
+
+    it('should write nothing for a window with no acquires', () => {
+        tracePool(pool.asPool());
+
+        clock.advance(windowMilliseconds * 3);
+
+        expect(tracer.metrics).toHaveLength(0);
+        expect(tracer.warnings).toHaveLength(0);
+    });
+
+    it('should write nothing for a window in which only a release happened', () => {
+        tracePool(pool.asPool());
+
+        pool.release({ total: 10, idle: 10, waiting: 0 });
+
+        clock.advance(windowMilliseconds);
+
+        expect(tracer.metrics).toHaveLength(0);
+    });
+
+    it('should report a storm that stopped in the middle of a window', () => {
+        tracePool(pool.asPool());
+
+        for (let i = 0; i < 200; i++) {
+            pool.acquire({ total: 10, idle: 0, waiting: 349 });
+        }
+        pool.release({ total: 10, idle: 0, waiting: 0 });
+
+        // The storm is over, and nothing touches the pool again. Only the
+        // window's own close can report it.
+        clock.advance(windowMilliseconds);
+
+        const lines = tracer.linesNamed('Postgres pool');
+        expect(lines).toHaveLength(1);
+        expect(lines[0].measurements.peakWaiting).toBe(349);
+
+        clock.advance(windowMilliseconds * 2);
+
+        expect(tracer.linesNamed('Postgres pool')).toHaveLength(1);
+    });
+
+    it('should start each window with a fresh peak', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 0, waiting: 349 });
+        clock.advance(windowMilliseconds);
+
+        pool.acquire({ total: 10, idle: 4, waiting: 0 });
+        clock.advance(windowMilliseconds);
+
+        const lines = tracer.linesNamed('Postgres pool');
+        expect(lines).toHaveLength(2);
+        expect(lines[0].measurements.peakWaiting).toBe(349);
+        expect(lines[1].measurements.peakWaiting).toBe(0);
+        expect(tracer.warnings).toHaveLength(1);
+    });
+
+    it('should not hold the process open with the timer it schedules', () => {
+        tracePool(pool.asPool());
+
+        expect(clock.only().hasRef()).toBe(false);
+    });
+
+    it('should stop reporting once the pool has ended', () => {
+        tracePool(pool.asPool());
+
+        pool.acquire({ total: 10, idle: 0, waiting: 0 });
+        clock.advance(windowMilliseconds);
+        expect(tracer.linesNamed('Postgres pool')).toHaveLength(1);
+
+        pool.acquire({ total: 10, idle: 0, waiting: 0 });
+        pool.ended = true;
+
+        clock.advance(windowMilliseconds * 5);
+
+        expect(tracer.linesNamed('Postgres pool')).toHaveLength(1);
+        expect(clock.live()).toHaveLength(0);
+    });
+
+    it('should still report each physical connection as it is made and removed', () => {
+        tracePool(pool.asPool());
+
+        pool.connect({ total: 1, idle: 0, waiting: 0 });
+        pool.remove({ total: 0, idle: 0, waiting: 0 });
+
+        expect(tracer.linesNamed('Postgres connected')).toEqual([{
+            message: 'Postgres connected',
+            measurements: { total: 1, idle: 0, waiting: 0 }
+        }]);
+        expect(tracer.linesNamed('Postgres disconnected')).toEqual([{
+            message: 'Postgres disconnected',
+            measurements: { total: 0, idle: 0, waiting: 0 }
+        }]);
+    });
+
+    it('should still report a pool error', () => {
+        tracePool(pool.asPool());
+
+        const error = new Error('connection terminated unexpectedly');
+        pool.fail(error);
+
+        expect(tracer.errors).toEqual([error]);
+    });
+});

package/test/postgres/purgeSqlSpec.ts

@@ -1,6 +1,6 @@
 import { Specification } from "jinaga";
 import { ensureGetFactTypeId, FactTypeMap, getRoleId } from "../../src/postgres/maps";
-import { purgeSqlFromSpecification } from "../../src/postgres/purge-sql";
+import { purgeSqlFromSpecification, purgeSqlFromSpecifications } from "../../src/postgres/purge-sql";
 import { model, Site, SiteDeleted, SitePurged } from "../models/blog";
 
 describe("Purge SQL", () => {
@@ -21,7 +21,7 @@ describe("Purge SQL", () => {
         const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
 
         const expected =
-`WITH candidates AS (
+`WITH candidates1 AS (
     SELECT
         f1.fact_id as purge_root,
         f2.fact_id as trigger1
@@ -32,20 +32,24 @@ describe("Purge SQL", () => {
     JOIN public.fact f2
         ON f2.fact_id = e1.successor_fact_id
     WHERE f1.fact_type_id = $1
+), roots AS (
+    SELECT purge_root FROM candidates1
+), triggers AS (
+    SELECT trigger1 AS fact_id FROM candidates1
 ), targets AS (
     SELECT a.fact_id
     FROM public.ancestor a
-    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    JOIN roots r ON r.purge_root = a.ancestor_fact_id
     WHERE NOT EXISTS (
         SELECT 1
-        FROM candidates c2
-        WHERE a.fact_id = c2.trigger1
+        FROM triggers t
+        WHERE a.fact_id = t.fact_id
     )
     AND NOT EXISTS (
         SELECT 1
-        FROM candidates c2
+        FROM triggers t
         JOIN public.ancestor a2
-            ON a2.fact_id = c2.trigger1
+            ON a2.fact_id = t.fact_id
         WHERE a.fact_id = a2.ancestor_fact_id
     )
 ), facts AS (
@@ -83,7 +87,7 @@ SELECT fact_id FROM facts
         const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
 
         const expected =
-`WITH candidates AS (
+`WITH candidates1 AS (
     SELECT
         f1.fact_id as purge_root,
         f3.fact_id as trigger1
@@ -99,20 +103,24 @@ SELECT fact_id FROM facts
     JOIN public.fact f3
         ON f3.fact_id = e2.successor_fact_id
     WHERE f1.fact_type_id = $1
+), roots AS (
+    SELECT purge_root FROM candidates1
+), triggers AS (
+    SELECT trigger1 AS fact_id FROM candidates1
 ), targets AS (
     SELECT a.fact_id
     FROM public.ancestor a
-    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    JOIN roots r ON r.purge_root = a.ancestor_fact_id
     WHERE NOT EXISTS (
         SELECT 1
-        FROM candidates c2
-        WHERE a.fact_id = c2.trigger1
+        FROM triggers t
+        WHERE a.fact_id = t.fact_id
     )
     AND NOT EXISTS (
         SELECT 1
-        FROM candidates c2
+        FROM triggers t
         JOIN public.ancestor a2
-            ON a2.fact_id = c2.trigger1
+            ON a2.fact_id = t.fact_id
         WHERE a.fact_id = a2.ancestor_fact_id
     )
 ), facts AS (
@@ -154,7 +162,7 @@ SELECT fact_id FROM facts
         const { sql, parameters } = whenGeneratePurgeSql(specification, factTypes, roleMap, schema);
 
         const expected =
-`WITH candidates AS (
+`WITH candidates1 AS (
     SELECT
         f1.fact_id as purge_root,
         f2.fact_id as trigger1,
@@ -171,28 +179,119 @@ SELECT fact_id FROM facts
     JOIN public.fact f3
         ON f3.fact_id = e2.successor_fact_id
     WHERE f1.fact_type_id = $1
+), roots AS (
+    SELECT purge_root FROM candidates1
+), triggers AS (
+    SELECT trigger1 AS fact_id FROM candidates1
+    UNION
+    SELECT trigger2 AS fact_id FROM candidates1
 ), targets AS (
     SELECT a.fact_id
     FROM public.ancestor a
-    JOIN candidates c ON c.purge_root = a.ancestor_fact_id
+    JOIN roots r ON r.purge_root = a.ancestor_fact_id
     WHERE NOT EXISTS (
         SELECT 1
-        FROM candidates c2
-        WHERE a.fact_id = c2.trigger1
-            OR a.fact_id = c2.trigger2
+        FROM triggers t
+        WHERE a.fact_id = t.fact_id
     )
     AND NOT EXISTS (
         SELECT 1
-        FROM candidates c2
+        FROM triggers t
         JOIN public.ancestor a2
-            ON a2.fact_id = c2.trigger1
+            ON a2.fact_id = t.fact_id
         WHERE a.fact_id = a2.ancestor_fact_id
     )
+), facts AS (
+    DELETE
+    FROM public.fact f
+    USING targets t WHERE t.fact_id = f.fact_id
+    RETURNING f.fact_id
+)
+SELECT fact_id FROM facts
+`;
+
+        expect(sql).toBe(expected);
+        expect(parameters).toEqual([
+            ensureGetFactTypeId(factTypes, Site.Type),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site'),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SitePurged.Type), 'deleted')
+        ]);
+    });
+    it("should spare the triggers of every condition on one given type", () => {
+        const deletedSpecification = model.given(Site).match((site, facts) =>
+            facts.ofType(SiteDeleted)
+                .join(deleted => deleted.site, site)
+        ).specification;
+        const purgedSpecification = model.given(Site).match((site, facts) =>
+            facts.ofType(SitePurged)
+                .join(purged => purged.deleted.site, site)
+        ).specification;
+        const factTypes = buildFactTypeMap(
+            Site.Type,
+            SiteDeleted.Type,
+            SitePurged.Type
+        );
+        const roleMap = buildRoleMap(factTypes,
+            [Site.Type, ['creator']],
+            [SiteDeleted.Type, ['site']],
+            [SitePurged.Type, ['deleted']]
+        );
+        const purgeCommand = purgeSqlFromSpecifications([deletedSpecification, purgedSpecification], factTypes, roleMap, 'public');
+        if (purgeCommand === null) {
+            throw new Error("The specifications were not satisfiable.");
+        }
+        const { sql, parameters } = purgeCommand;
+
+        const expected =
+`WITH candidates1 AS (
+    SELECT
+        f1.fact_id as purge_root,
+        f2.fact_id as trigger1
+    FROM public.fact f1
+    JOIN public.edge e1
+        ON e1.predecessor_fact_id = f1.fact_id
+        AND e1.role_id = $2
+    JOIN public.fact f2
+        ON f2.fact_id = e1.successor_fact_id
+    WHERE f1.fact_type_id = $1
+), candidates2 AS (
+    SELECT
+        f1.fact_id as purge_root,
+        f3.fact_id as trigger1
+    FROM public.fact f1
+    JOIN public.edge e1
+        ON e1.predecessor_fact_id = f1.fact_id
+        AND e1.role_id = $4
+    JOIN public.fact f2
+        ON f2.fact_id = e1.successor_fact_id
+    JOIN public.edge e2
+        ON e2.predecessor_fact_id = f2.fact_id
+        AND e2.role_id = $5
+    JOIN public.fact f3
+        ON f3.fact_id = e2.successor_fact_id
+    WHERE f1.fact_type_id = $3
+), roots AS (
+    SELECT purge_root FROM candidates1
+    UNION
+    SELECT purge_root FROM candidates2
+), triggers AS (
+    SELECT trigger1 AS fact_id FROM candidates1
+    UNION
+    SELECT trigger1 AS fact_id FROM candidates2
+), targets AS (
+    SELECT a.fact_id
+    FROM public.ancestor a
+    JOIN roots r ON r.purge_root = a.ancestor_fact_id
+    WHERE NOT EXISTS (
+        SELECT 1
+        FROM triggers t
+        WHERE a.fact_id = t.fact_id
+    )
     AND NOT EXISTS (
         SELECT 1
-        FROM candidates c2
+        FROM triggers t
         JOIN public.ancestor a2
-            ON a2.fact_id = c2.trigger2
+            ON a2.fact_id = t.fact_id
         WHERE a.fact_id = a2.ancestor_fact_id
     )
 ), facts AS (
@@ -206,6 +305,8 @@ SELECT fact_id FROM facts
 
         expect(sql).toBe(expected);
         expect(parameters).toEqual([
+            ensureGetFactTypeId(factTypes, Site.Type),
+            getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site'),
             ensureGetFactTypeId(factTypes, Site.Type),
             getRoleId(roleMap, ensureGetFactTypeId(factTypes, SiteDeleted.Type), 'site'),
             getRoleId(roleMap, ensureGetFactTypeId(factTypes, SitePurged.Type), 'deleted')