@playwright-orchestrator/pg 1.1.4 → 1.2.1

package/dist/postgresql-adapter.d.ts

@@ -1,17 +1,23 @@
-import { TestItem, TestRunInfo, Adapter, TestRunConfig } from '@playwright-orchestrator/core';
+import { TestItem, Adapter, TestRunConfig, ResultTestParams, SaveTestRunParams } from '@playwright-orchestrator/core';
 import { CreateArgs } from './create-args.js';
+import { TestRunReport } from '../../core/dist/types/reporter.js';
 export declare class PostgreSQLAdapter extends Adapter {
     private readonly configTable;
     private readonly testsTable;
+    private readonly testInfoTable;
+    private readonly testInfoHistoryTable;
     private readonly pool;
     constructor({ connectionString, tableNamePrefix, sslCa, sslCert, sslKey }: CreateArgs);
     getNextTest(runId: string, config: TestRunConfig): Promise<TestItem | undefined>;
-    finishTest(runId: string, test: TestItem): Promise<void>;
-    failTest(runId: string, test: TestItem): Promise<void>;
-    private updateTestStatus;
-    saveTestRun(runId: string, testRun: TestRunInfo, args: string[]): Promise<void>;
+    finishTest(params: ResultTestParams): Promise<void>;
+    failTest(params: ResultTestParams): Promise<void>;
+    saveTestRun({ runId, args, historyWindow, testRun }: SaveTestRunParams): Promise<void>;
     initialize(): Promise<void>;
     startShard(runId: string): Promise<TestRunConfig>;
     finishShard(runId: string): Promise<void>;
     dispose(): Promise<void>;
+    getReportData(runId: string): Promise<TestRunReport>;
+    private updateTestWithResults;
+    private loadTestInfos;
+    private mapConfig;
 }

package/dist/postgresql-adapter.js

@@ -1,8 +1,10 @@
-import { Adapter, RunStatus, TestStatus } from '@playwright-orchestrator/core';
+import { Adapter, RunStatus, TestStatus, } from '@playwright-orchestrator/core';
 import pg from 'pg';
 export class PostgreSQLAdapter extends Adapter {
     configTable;
     testsTable;
+    testInfoTable;
+    testInfoHistoryTable;
     pool;
     constructor({ connectionString, tableNamePrefix, sslCa, sslCert, sslKey }) {
         super();
@@ -18,13 +20,14 @@ export class PostgreSQLAdapter extends Adapter {
         this.pool = new pg.Pool(config);
         this.configTable = pg.escapeIdentifier(`${tableNamePrefix}_test_runs`);
         this.testsTable = pg.escapeIdentifier(`${tableNamePrefix}_tests`);
+        this.testInfoTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info`);
+        this.testInfoHistoryTable = pg.escapeIdentifier(`${tableNamePrefix}_test_info_history`);
     }
     async getNextTest(runId, config) {
         const client = await this.pool.connect();
         try {
             await client.query('BEGIN');
             const result = await client.query({
-                name: 'select-next-test',
                 text: `WITH next_test AS (
                     SELECT order_num FROM ${this.testsTable}
                     WHERE run_id = $1 AND status = $2
@@ -52,31 +55,22 @@ export class PostgreSQLAdapter extends Adapter {
             client.release();
         }
     }
-    async finishTest(runId, test) {
-        await this.updateTestStatus(runId, test, TestStatus.Passed);
+    async finishTest(params) {
+        await this.updateTestWithResults(TestStatus.Passed, params);
     }
-    async failTest(runId, test) {
-        await this.updateTestStatus(runId, test, TestStatus.Failed);
+    async failTest(params) {
+        await this.updateTestWithResults(TestStatus.Failed, params);
     }
-    async updateTestStatus(runId, test, status) {
+    async saveTestRun({ runId, args, historyWindow, testRun }) {
+        let tests = this.transformTestRunToItems(testRun.testRun);
+        const testInfos = await this.loadTestInfos(tests);
+        tests = this.sortTests(tests, testInfos, { historyWindow });
         await this.pool.query({
-            name: 'update-test-status',
-            text: `UPDATE ${this.testsTable}
-            SET status = $1, updated = NOW()
-            WHERE run_id = $2 AND order_num = $3`,
-            values: [status, runId, test.order],
-        });
-    }
-    async saveTestRun(runId, testRun, args) {
-        await this.pool.query({
-            name: 'insert-config',
             text: `INSERT INTO ${this.configTable} (id, status, config) VALUES ($1, $2, $3)`,
-            values: [runId, RunStatus.Created, JSON.stringify({ ...testRun.config, args })],
+            values: [runId, RunStatus.Created, JSON.stringify({ ...testRun.config, args, historyWindow })],
         });
-        const tests = this.flattenTestRun(testRun.testRun);
         const fields = ['order_num', 'file', 'line', 'character', 'project', 'timeout'];
         await this.pool.query({
-            name: 'insert-tests',
             text: `INSERT INTO ${this.testsTable} (run_id, ${fields.join(', ')}) VALUES ${tests
                 .map((_, i) => {
                 const len = fields.length;
@@ -110,10 +104,27 @@ export class PostgreSQLAdapter extends Adapter {
                 project TEXT NOT NULL,
                 timeout INT NOT NULL,
                 updated TIMESTAMP NOT NULL DEFAULT NOW(),
+                report JSONB,
                 PRIMARY KEY (run_id, order_num),
                 FOREIGN KEY (run_id) REFERENCES ${this.configTable}(id)
             );
-            CREATE INDEX IF NOT EXISTS status_idx ON ${this.testsTable}(status);`);
+            CREATE INDEX IF NOT EXISTS status_idx ON ${this.testsTable}(status);
+            CREATE TABLE IF NOT EXISTS ${this.testInfoTable} (
+                id SERIAL PRIMARY KEY,
+                name TEXT NOT NULL,
+                ema FLOAT NOT NULL DEFAULT 0,
+                created TIMESTAMP NOT NULL DEFAULT NOW()
+            );
+            CREATE INDEX IF NOT EXISTS name_idx ON ${this.testInfoTable} USING HASH (name);
+            CREATE TABLE IF NOT EXISTS ${this.testInfoHistoryTable} (
+                id SERIAL PRIMARY KEY,
+                duration FLOAT NOT NULL,
+                status INT NOT NULL,
+                updated TIMESTAMP NOT NULL DEFAULT NOW(),
+                test_info_id INT NOT NULL,
+                FOREIGN KEY (test_info_id) REFERENCES ${this.testInfoTable}(id)
+            );
+            CREATE INDEX IF NOT EXISTS test_info_id_idx ON ${this.testInfoHistoryTable}(test_info_id);`);
     }
     async startShard(runId) {
         const client = await this.pool.connect();
@@ -154,9 +165,7 @@ export class PostgreSQLAdapter extends Adapter {
                 });
             }
             await client.query('COMMIT');
-            const { updated, status, config } = result.rows[0];
-            const mappedConfig = { ...config, updated: updated.getTime(), status };
-            return mappedConfig;
+            return this.mapConfig(result.rows[0]);
         }
         catch (e) {
             await client.query('ROLLBACK');
@@ -170,7 +179,6 @@ export class PostgreSQLAdapter extends Adapter {
         // set 'updated' field to current time as test run exhausted all tests
         // update 'updated' field until last shard set correct finish time
         await this.pool.query({
-            name: 'update-finish-config',
             text: `UPDATE ${this.configTable}
             SET status = $1,
             updated = NOW()
@@ -183,4 +191,137 @@ export class PostgreSQLAdapter extends Adapter {
             return;
         await this.pool.end();
     }
+    async getReportData(runId) {
+        const { rows: [dbConfig], } = await this.pool.query({
+            text: `SELECT * FROM ${this.configTable} WHERE id = $1`,
+            values: [runId],
+        });
+        if (!dbConfig)
+            throw new Error(`Run ${runId} not found`);
+        const { rows } = await this.pool.query({
+            text: `SELECT * FROM ${this.testsTable} WHERE run_id = $1`,
+            values: [runId],
+        });
+        return {
+            runId,
+            config: this.mapConfig(dbConfig),
+            tests: rows.map(({ file, project, line, character, report }) => ({
+                averageDuration: 0,
+                duration: report?.duration ?? 0,
+                status: report?.status ?? TestStatus.Ready,
+                fails: report?.fails ?? 0,
+                file,
+                position: `${line}:${character}`,
+                project,
+                title: report?.title,
+                lastSuccessfulRunTimestamp: report?.lastSuccessfulRun,
+            })),
+        };
+    }
+    async updateTestWithResults(status, { runId, test, config, testResult }) {
+        const testId = this.getTestId({ ...test, ...testResult });
+        const { rows: [testInfo], } = await this.pool.query({
+            text: `SELECT 
+                id, 
+                ema,
+                (
+                    SELECT COUNT(*) FROM ${this.testInfoHistoryTable} 
+                    WHERE status = ${TestStatus.Failed} AND test_info_id = info.id
+                ) AS fails,
+                (
+                    SELECT updated FROM ${this.testInfoHistoryTable} 
+                    WHERE status = ${TestStatus.Passed} AND test_info_id = info.id 
+                    ORDER BY updated DESC LIMIT 1
+                ) AS last_successful_run
+            FROM ${this.testInfoTable} info
+            WHERE name = $1`,
+            values: [testId],
+        });
+        const report = {
+            title: testResult.title,
+            status,
+            duration: testResult.duration,
+            ema: testInfo.ema,
+            fails: +testInfo.fails,
+            lastSuccessfulRun: testInfo.last_successful_run?.getTime?.(),
+        };
+        const newEma = this.calculateEMA(testResult.duration, testInfo.ema, config.historyWindow);
+        await this.pool.query({
+            text: `UPDATE ${this.testsTable}
+            SET 
+                status = $1,
+                updated = NOW(),
+                report = $2 
+            WHERE run_id = $3 AND order_num = $4;`,
+            values: [status, report, runId, test.order],
+        });
+        await this.pool.query({
+            text: `UPDATE ${this.testInfoTable} SET ema = $1 WHERE id = $2;`,
+            values: [newEma, testInfo.id],
+        });
+        await this.pool.query({
+            text: `INSERT INTO ${this.testInfoHistoryTable} (status, duration, updated, test_info_id)
+            VALUES ($1, $2, NOW(), $3);`,
+            values: [status, testResult.duration, testInfo.id],
+        });
+        await this.pool.query({
+            text: `DELETE FROM ${this.testInfoHistoryTable}
+            WHERE id IN (
+                SELECT id 
+                FROM ${this.testInfoHistoryTable}
+                WHERE test_info_id = $1
+                ORDER BY updated
+                LIMIT 10
+                OFFSET 10
+            )`,
+            values: [testInfo.id],
+        });
+    }
+    async loadTestInfos(tests) {
+        const results = await this.pool.query({
+            text: `
+            WITH test_names AS (
+                SELECT UNNEST($1::TEXT[]) AS name
+            ),
+            existing_tests AS (
+                SELECT id, name, ema, created FROM ${this.testInfoTable}
+                WHERE name IN (SELECT name FROM test_names)
+            ),
+            inserted_tests AS (
+                INSERT INTO ${this.testInfoTable} (name)
+                SELECT name FROM test_names
+                WHERE NOT EXISTS (
+                    SELECT 1 FROM ${this.testInfoTable} WHERE name = test_names.name
+                )
+                RETURNING id, name, ema, created
+            ),
+            combined_tests AS (
+                SELECT * FROM existing_tests
+                UNION ALL
+                SELECT * FROM inserted_tests
+            )
+            SELECT 
+                t.id,
+                t.name,
+                t.ema,
+                t.created,
+                COUNT(CASE WHEN h.status = ${TestStatus.Failed} THEN 1 END) as fails
+            FROM combined_tests t
+            LEFT JOIN ${this.testInfoHistoryTable} h ON h.test_info_id = t.id
+            GROUP BY t.id, t.name, t.ema, t.created`,
+            values: [tests.map((t) => t.testId)],
+        });
+        const testInfo = new Map();
+        for (const { name, ema, fails } of results.rows) {
+            testInfo.set(name, { ema, fails: +fails });
+        }
+        return testInfo;
+    }
+    mapConfig(dbConfig) {
+        return {
+            ...dbConfig.config,
+            updated: dbConfig.updated.getTime(),
+            status: dbConfig.status,
+        };
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@playwright-orchestrator/pg",
-    "version": "1.1.4",
+    "version": "1.2.1",
     "keywords": [],
     "author": "Rostyslav Kudrevatykh",
     "license": "Apache-2.0",