@piwitests/reporter 0.4.2

package/dist/uploader.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uploader = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const form_data_1 = __importDefault(require("form-data"));
+const serializer_js_1 = require("./serializer.js");
+/**
+ * Handles all upload strategies: plain JSON, multipart (with reports and
+ * traces), per-test-case file uploads for streaming runs, and report-only
+ * uploads for already-submitted streaming runs.
+ */
+class Uploader {
+    /**
+     * @param httpClient  HTTP client for server communication.
+     * @param fileHandler File discovery and compression helper.
+     * @param logger      Prefixed logger.
+     */
+    constructor(httpClient, fileHandler, logger) {
+        this.httpClient = httpClient;
+        this.fileHandler = fileHandler;
+        this.logger = logger;
+    }
+    /** Submit test results as a plain JSON payload (no file attachments) */
+    async uploadJSON(payload, auth) {
+        const response = await this.httpClient.postJSON('/api/test-runs/submit', (0, serializer_js_1.serializeRun)(payload, { includeTestCases: true }), auth);
+        this.logger.info(`Successfully uploaded test results`);
+        if (response.testRunId)
+            this.logger.info(`Test Run ID: ${response.testRunId}, Project ID: ${response.projectId}`);
+        return response;
+    }
+    /** Submit test results as a multipart form with trace files and compressed report directories */
+    async uploadWithFiles(payload, reportOptions, auth) {
+        const form = new form_data_1.default();
+        form.append('projectName', payload.projectName);
+        form.append('testRun', JSON.stringify((0, serializer_js_1.serializeRun)(payload, { includeTestCases: false })));
+        form.append('testCases', JSON.stringify(payload.testCases.map((tc) => (0, serializer_js_1.toWireTestCase)(tc))));
+        await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
+        await this.appendFilesToForm(form, payload.testCases, reportOptions.uploadTraces);
+        const response = await this.httpClient.postFormData('/api/test-runs/upload', form, auth);
+        this.logger.info(`Successfully uploaded test results with files`);
+        if (response.testRunId)
+            this.logger.info(`Test Run ID: ${response.testRunId}, Project ID: ${response.projectId}`);
+        if (response.reports) {
+            for (const r of response.reports)
+                this.logger.info(`${r.label}: ${r.path}`);
+        }
+        return response;
+    }
+    /** Upload report files for an already-submitted streaming run */
+    async uploadReportsForStreamingRun(projectName, runId, reportOptions, startTime, auth) {
+        const form = new form_data_1.default();
+        form.append('testRunId', String(runId));
+        form.append('projectName', projectName);
+        form.append('testRun', JSON.stringify({
+            status: 'already-submitted',
+            startTime,
+            duration: 0,
+            totalTests: 0,
+            passedTests: 0,
+            failedTests: 0,
+            skippedTests: 0,
+            metadata: {},
+        }));
+        form.append('testCases', JSON.stringify([]));
+        await this.appendReportsToForm(form, reportOptions.reports, reportOptions.uploadReport);
+        const response = await this.httpClient.postFormData('/api/test-runs/upload', form, auth);
+        this.logger.info(`Successfully uploaded reports for streaming run #${runId}`);
+        if (response.reports) {
+            for (const r of response.reports)
+                this.logger.info(`${r.label}: ${r.path}`);
+        }
+    }
+    /**
+     * Upload one test case's trace and attachments for a streaming run.
+     * The matching `complete` event must have been flushed to the server first.
+     * Returns `false` when the case has no files to upload.
+     */
+    async uploadCaseFiles(projectName, runId, streamToken, testCase, uploadTraces, auth) {
+        const attachments = this.fileHandler.findAllAttachments(testCase);
+        let traceInfo = null;
+        if (uploadTraces) {
+            traceInfo = await this.fileHandler.computeSingleTraceHash(testCase);
+        }
+        if (!traceInfo && attachments.length === 0)
+            return false;
+        // Skip the trace body when the server already has this blob
+        let missingHashes = null;
+        if (traceInfo) {
+            missingHashes = await this.fileHandler.checkMissingTraces(this.httpClient, projectName, new Map([[0, traceInfo]]), auth);
+        }
+        const buildForm = (includeTraceFile) => {
+            const form = new form_data_1.default();
+            form.append('streamToken', streamToken);
+            form.append('testCase', JSON.stringify({
+                title: testCase.title,
+                location: testCase.location,
+                retries: testCase.retries ?? 0,
+                suitePath: testCase.suitePath ?? null,
+            }));
+            if (traceInfo) {
+                form.append('trace_hash', traceInfo.hash);
+                if (includeTraceFile) {
+                    form.append('trace', fs_1.default.createReadStream(traceInfo.tracePath), {
+                        filename: path_1.default.basename(traceInfo.tracePath),
+                    });
+                }
+            }
+            if (attachments.length > 0) {
+                form.append('attach_meta', JSON.stringify(attachments.map((a) => ({ name: a.name, contentType: a.contentType, originalName: a.originalName }))));
+                for (const a of attachments) {
+                    form.append('attach_file', fs_1.default.createReadStream(a.path), { filename: a.originalName });
+                }
+            }
+            return form;
+        };
+        const includeTraceFile = !traceInfo || !missingHashes || missingHashes.has(traceInfo.hash);
+        try {
+            await this.httpClient.postFormData(`/api/test-runs/${runId}/case-files`, buildForm(includeTraceFile), auth);
+        }
+        catch (error) {
+            // 422: the server doesn't have the blob after all — resend with the file
+            if (traceInfo && !includeTraceFile && error.message?.includes('422')) {
+                await this.httpClient.postFormData(`/api/test-runs/${runId}/case-files`, buildForm(true), auth);
+            }
+            else {
+                throw error;
+            }
+        }
+        this.logger.debug(`Uploaded files for "${testCase.title}" (trace: ${traceInfo ? 'yes' : 'no'}, attachments: ${attachments.length})`);
+        return true;
+    }
+    async appendReportsToForm(form, reports, uploadReport) {
+        const list = reports ? [...reports] : [];
+        if (uploadReport && !list.some((r) => r.type === 'html'))
+            list.push({ type: 'html' });
+        for (const cfg of list) {
+            const defaultDir = this.fileHandler.getDefaultReportDirs()[cfg.type] || cfg.type + '-report';
+            const reportDir = cfg.dir
+                ? this.fileHandler.findReportDirectory(cfg.dir)
+                : cfg.type === 'html'
+                    ? this.fileHandler.findHTMLReportDirectory()
+                    : this.fileHandler.findReportDirectory(defaultDir);
+            if (!reportDir) {
+                this.logger.debug(`No report directory found for type '${cfg.type}'`);
+                continue;
+            }
+            const compressed = await this.fileHandler.compressReportDirectory(reportDir);
+            if (compressed) {
+                form.append(`report_${cfg.type}`, compressed, { filename: `${cfg.type}-report.gz` });
+                if (cfg.label)
+                    form.append(`report_label_${cfg.type}`, cfg.label);
+            }
+        }
+    }
+    async appendFilesToForm(form, testCases, uploadTraces) {
+        let attachmentCount = 0;
+        for (const [i, tc] of testCases.entries()) {
+            const attachments = this.fileHandler.findAllAttachments(tc);
+            if (attachments.length === 0)
+                continue;
+            form.append(`attach_meta_${i}`, JSON.stringify(attachments.map((a) => ({
+                name: a.name,
+                contentType: a.contentType,
+                originalName: a.originalName,
+            }))));
+            for (const a of attachments) {
+                form.append(`attach_file_${i}`, fs_1.default.createReadStream(a.path), { filename: a.originalName });
+                attachmentCount++;
+            }
+        }
+        if (attachmentCount > 0)
+            this.logger.info(`Uploading ${attachmentCount} non-trace attachments`);
+        if (!uploadTraces)
+            return;
+        let traceCount = 0;
+        for (const [i, tc] of testCases.entries()) {
+            for (const tp of this.fileHandler.findTraceFiles(tc)) {
+                if (fs_1.default.existsSync(tp)) {
+                    form.append(`trace_${i}`, fs_1.default.createReadStream(tp), { filename: path_1.default.basename(tp) });
+                    traceCount++;
+                }
+            }
+        }
+        this.logger.info(`Found ${traceCount} trace files`);
+    }
+}
+exports.Uploader = Uploader;

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@piwitests/reporter",
+  "version": "0.4.2",
+  "description": "Playwright reporter for sending test results to Piwi Dashboard",
+  "url": "https://github.com/PiwiTests/platform",
+  "homepage": "https://piwitests.github.io",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/PiwiTests/platform"
+  },
+  "bugs": {
+    "url": "https://github.com/PiwiTests/platform/issues"
+  },
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./fixtures": {
+      "types": "./dist/fixtures.d.ts",
+      "import": "./dist/fixtures.js",
+      "require": "./dist/fixtures.js"
+    }
+  },
+  "keywords": [
+    "playwright",
+    "reporter",
+    "dashboard",
+    "test-results"
+  ],
+  "author": "piwitests",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "reporter:build": "tsc",
+    "reporter:dev": "tsc --watch",
+    "reporter:format": "oxfmt --config oxfmt.config.mts --write \"src/\"",
+    "reporter:format:check": "oxfmt --config oxfmt.config.mts --check \"src/\"",
+    "reporter:lint": "oxlint --config oxlint.config.mts .",
+    "reporter:lint:fix": "oxlint --config oxlint.config.mts . --fix",
+    "reporter:test": "vitest run",
+    "reporter:test:watch": "vitest",
+    "test": "npm run reporter:test",
+    "prepublishOnly": "npm run reporter:build"
+  },
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "@playwright/test": "^1.40.0"
+  },
+  "dependencies": {
+    "form-data": "^4.0.0"
+  }
+}