playwright-s3-reporter/dist/reporter.js

A Playwright Reporter for uploading traces to S3 compatible services.

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const client_s3_1 = require("@aws-sdk/client-s3");
const fs_1 = require("fs");
const promises_1 = require("fs/promises");
const path_1 = __importDefault(require("path"));
const mime_1 = __importDefault(require("mime"));
class S3Reporter {
    constructor(options) {
        this.options = options;
    }
    onExit() {
        return __awaiter(this, void 0, void 0, function* () {
            console.log(`[${S3Reporter.name}] Discovering files...`);
            const { credentials, endpoint, sslEnabled, region, customUserAgent, maxAttempts, bucketName, baseUploadKey, uploadTestResults, uploadReport, } = this.options;
            const s3 = new client_s3_1.S3Client({
                credentials,
                endpoint,
                forcePathStyle: true,
                tls: sslEnabled,
                region,
                customUserAgent,
                maxAttempts,
            });
            const files = [];
            if (uploadTestResults) {
                const testResultsFiles = yield this.getFiles("test-results");
                files.push(...testResultsFiles);
                console.log(`[${S3Reporter.name}] Discovered ${testResultsFiles.length} files in test-results/.`);
            }
            if (uploadReport) {
                const playwrightReportFiles = yield this.getFiles("playwright-report");
                files.push(...playwrightReportFiles);
                console.log(`[${S3Reporter.name}] Discovered ${playwrightReportFiles.length} files in playwright-report/.`);
            }
            console.log(`[${S3Reporter.name}] Uploading ${files.length} files...`);
            let totalUploadErrors = 0;
            const uploads = files.map((filePath) => __awaiter(this, void 0, void 0, function* () {
                const metaData = {};
                let sourceDirectory = "";
                if (filePath.includes("test-results")) {
                    sourceDirectory = "test-results";
                }
                if (filePath.includes("playwright-report")) {
                    sourceDirectory = "playwright-report";
                }
                const key = path_1.default
                    .join(baseUploadKey !== null && baseUploadKey !== void 0 ? baseUploadKey : "", sourceDirectory, path_1.default.relative(sourceDirectory, filePath))
                    .split(/[\\/]/g)
                    .join("/");
                try {
                    const putObjectParams = {
                        Bucket: bucketName,
                        Key: key,
                        Body: (0, fs_1.createReadStream)(filePath),
                        Metadata: metaData,
                        ContentType: mime_1.default.getType(filePath),
                    };
                    const putObjectCommand = new client_s3_1.PutObjectCommand(putObjectParams);
                    const response = yield s3.send(putObjectCommand);
                    console.log(`[${S3Reporter.name}] File uploaded successfully: ${key} (${response.$metadata.httpStatusCode})`);
                }
                catch (error) {
                    console.error(`[${S3Reporter.name}] Error uploading file: `, error);
                    totalUploadErrors += 1;
                }
            }));
            yield Promise.all(uploads);
            console.log(`[${S3Reporter.name}] Upload completed with ${totalUploadErrors} errors!`);
        });
    }
    getFiles(directory) {
        return __awaiter(this, void 0, void 0, function* () {
            const _directories = yield (0, promises_1.readdir)(directory, { withFileTypes: true });
            const _files = yield Promise.all(_directories.map((_directory) => {
                const resolvedPath = path_1.default.resolve(directory, _directory.name);
                return _directory.isDirectory()
                    ? this.getFiles(resolvedPath)
                    : resolvedPath;
            }));
            return Array.prototype.concat(..._files);
        });
    }
}
exports.default = S3Reporter;