@bigbinary/neeto-playwright-reporter 1.0.1 → 1.1.0

package/index.d.ts

@@ -1,8 +1,20 @@
-import { Reporter, FullConfig, Suite } from '@playwright/test/reporter';
+import { Reporter, FullConfig, Suite, TestCase, TestResult, FullResult } from '@playwright/test/reporter';
 
+interface ReporterOptionParams {
+    projectKey: string;
+    baseURL: string;
+    ciBuildId: string;
+}
 declare class MyReporter implements Reporter {
-    constructor(options: Record<string, string>);
-    onBegin: (config: FullConfig, suite: Suite) => Promise<void>;
+    attempts: Record<string, string>;
+    ciBuildId: string;
+    config: FullConfig | undefined;
+    currentShard: number | undefined;
+    constructor(options: ReporterOptionParams);
+    onBegin: (config: FullConfig, rootSuite: Suite) => Promise<void>;
+    onTestBegin: ({ id, title }: TestCase, { retry }: TestResult) => Promise<void>;
+    onTestEnd: ({ id, title }: TestCase, { status, duration, errors, retry, attachments }: TestResult) => Promise<void>;
+    onEnd: ({ status, duration }: FullResult) => Promise<void>;
 }
 
 export { MyReporter as default };

package/index.js

@@ -1,15 +1,16 @@
+import require$$6 from 'fs';
 import require$$1, { TextEncoder } from 'util';
 import stream, { Readable } from 'stream';
 import require$$1$1 from 'path';
 import require$$3 from 'http';
 import require$$4 from 'https';
 import require$$0$1 from 'url';
-import require$$6 from 'fs';
 import require$$4$1 from 'assert';
 import require$$1$2 from 'tty';
 import require$$0$2 from 'os';
 import zlib from 'zlib';
 import EventEmitter from 'events';
+import childProcess from 'child_process';
 
 function bind(fn, thisArg) {
   return function wrap() {
@@ -18429,54 +18430,207 @@ axios.HttpStatusCode = HttpStatusCode;
 
 axios.default = axios;
 
-// dummy endpoint until neeto-playwright-reporter dashboard is up
-const create = (payload) => axios.post(`https://webhook.site/1bff83d0-03a0-412f-a70a-2f11f3209534`, payload);
-const dummyApi = { create };
-
-const getDescribePath = ({ titlePath, title, project, spec, }) => {
-    const describePaths = titlePath.filter((item, index) => index !== 0 && item !== title && item !== project && item !== spec);
-    return describePaths.join(" > ");
-};
-
 const HEADERS_KEYS = {
     applicationKey: "Application-Key",
-    xCsrfToken: "X-CSRF-TOKEN",
     contentType: "Content-Type",
     accept: "Accept",
+    apiKey: "X-Api-Key",
+    projectKey: "Project-Key",
+};
+const API_BASE_URL = "/api/v1";
+
+const create$2 = (ciBuildId, history_id, payload) => axios.post(`${API_BASE_URL}/reporter/runs/${ciBuildId}/test_entities/${history_id}/attempts`, payload, { headers: { "Content-Type": "multipart/form-data" } });
+const update$1 = (ciBuildId, history_id, id, payload) => axios.put(`${API_BASE_URL}/reporter/runs/${ciBuildId}/test_entities/${history_id}/attempts/${id}`, payload, { headers: { "Content-Type": "multipart/form-data" } });
+const attemptsApi = { create: create$2, update: update$1 };
+
+const ERRORS = {
+    onBegin: {
+        failedToGetCommitSha: "Failed to get current commit SHA.",
+        failedToGetCommitMessage: "Failed to get current commit message.",
+        failedToInitializeRun: "Failed to initialize run in reporter",
+    },
+    onTestBegin: {
+        failedToReportTest: (testTitle, historyId) => `Failed to report test "${testTitle}" with history ID ${historyId}`,
+    },
+    onEnd: {
+        failedToReportRunStatus: "Failed to report run status",
+    },
 };
 
-const setAuthHeaders = (applicationKey) => {
+const MESSAGES = {
+    onBegin: {
+        testStarted: "Test has started reporting to neetoPlaywrightReporter",
+        ciBuildId: (currentCiBuildId) => `CI BUILD ID: ${currentCiBuildId}`,
+        totalShards: (totalShards) => `Total shards: ${totalShards}`,
+        currentShard: (currentShard) => `Current shard: ${currentShard}`,
+    },
+};
+
+const consoleLogFormatted = {
+    bold: (message) => console.log(console.log("\x1b[1m", message, "\x1b[0m")),
+    dim: (message) => console.log(console.log("\x1b[2m", message, "\x1b[0m")),
+    underline: (message) => console.log(console.log("\x1b[4m", message, "\x1b[0m")),
+    invertBackground: (message) => console.log(console.log("\x1b[7m", message, "\x1b[0m")),
+    hidden: (message) => console.log(console.log("\x1b[8m", message, "\x1b[0m")),
+    error: (message) => console.log("\u001b[31m", "\x1b[1m", message, "\x1b[0m", "\u001b[0m"),
+    warning: (message) => console.log("\u001b[33m", "\x1b[1m", message, "\x1b[0m", "\u001b[0m"),
+};
+const executeCommandLine = ({ command, messageOnError, shouldThrowError = false, logLevel = "warning", }) => {
+    try {
+        return childProcess.execSync(command).toString().trim();
+    }
+    catch (err) {
+        if (shouldThrowError) {
+            throw err;
+        }
+        else {
+            consoleLogFormatted[logLevel](messageOnError);
+        }
+    }
+};
+
+const createShardObject = ({ currentShard = 0, status = "running", duration = null, }) => ({
+    [currentShard]: { status, duration },
+});
+const convertBufferToBlob = (buffer, contentType) => new Blob([buffer], { type: contentType });
+
+const getDescribePath = ({ titlePath, title, project, spec, }) => titlePath.filter((item, index) => index !== 0 && item !== title && item !== project && item !== spec);
+const getCurrentCommitSha = () => executeCommandLine({
+    command: "git rev-parse HEAD",
+    messageOnError: ERRORS.onBegin.failedToGetCommitSha,
+});
+const getCurrentCommitMessage = () => executeCommandLine({
+    command: "git show-branch --no-name HEAD",
+    messageOnError: ERRORS.onBegin.failedToGetCommitMessage,
+});
+const getInitializerData = ({ rootDir }, rootSuite) => rootSuite.allTests().map(test => {
+    var _a;
+    const { title, parent, id: history_id, location: { file }, } = test;
+    const titlePath = test.titlePath();
+    const project = (_a = parent.project()) === null || _a === void 0 ? void 0 : _a.name;
+    const spec = file.replace(`${rootDir}/`, "");
+    const describe = getDescribePath({ titlePath, title, spec, project });
+    return { title, describe, project, spec, history_id };
+});
+
+const setAuthHeaders = (projectKey) => {
+    var _a;
     axios.defaults.headers = {
         ...axios.defaults.headers,
-        [HEADERS_KEYS.applicationKey]: applicationKey,
+        [HEADERS_KEYS.projectKey]: projectKey,
+        [HEADERS_KEYS.apiKey]: (_a = process.env.API_KEY) !== null && _a !== void 0 ? _a : "",
         [HEADERS_KEYS.accept]: "application/json",
         [HEADERS_KEYS.contentType]: "application/json",
     };
 };
-function initializeAxios(applicationKey) {
-    setAuthHeaders(applicationKey);
+function initializeAxios({ projectKey, baseURL, }) {
+    axios.defaults.baseURL = baseURL;
+    setAuthHeaders(projectKey);
 }
 
+const create$1 = (payload) => axios.post(`${API_BASE_URL}/reporter/runs`, {
+    run: payload,
+});
+const update = (ciBuildId, payload) => axios.put(`${API_BASE_URL}/reporter/runs/${ciBuildId}`, {
+    run: payload,
+});
+const runsApi = { create: create$1, update };
+
+const create = (ciBuildId, payload) => axios.post(`${API_BASE_URL}/reporter/runs/${ciBuildId}/test_entities`, {
+    test_entity: payload,
+});
+const testEntitiesApi = { create };
+
 class MyReporter {
     constructor(options) {
-        this.onBegin = async (config, suite) => {
-            console.log("Run begin".padStart(5, "\n").padEnd(5, "\n"));
-            console.log("Config".padStart(20, "*").padEnd(40, "*"));
-            console.log(JSON.stringify(config, null, 4));
-            console.log("Suite".padStart(20, "*").padEnd(40, "*"));
-            const initializerData = suite.allTests().map(test => {
-                var _a;
-                const { rootDir } = config;
-                const { title, parent, id: history_id, location: { file }, } = test;
-                const titlePath = test.titlePath();
-                const project = (_a = parent.project()) === null || _a === void 0 ? void 0 : _a.name;
-                const spec = file.replace(`${rootDir}/`, "");
-                const describe = getDescribePath({ titlePath, title, spec, project });
-                return { title, describe, project, spec, history_id };
-            });
-            await dummyApi.create({ test_entity: { initializerData, config } });
+        this.onBegin = async (config, rootSuite) => {
+            const shard = config.shard;
+            let attempts;
+            try {
+                const runDetails = {
+                    commit_id: getCurrentCommitSha(),
+                    commit_name: getCurrentCommitMessage(),
+                    ci_build_id: this.ciBuildId,
+                    configuration: config,
+                    shards: createShardObject({ currentShard: shard === null || shard === void 0 ? void 0 : shard.current }),
+                };
+                await runsApi.create(runDetails);
+                ({ data: attempts } = await testEntitiesApi.create(this.ciBuildId, {
+                    test_entities: getInitializerData(config, rootSuite),
+                }));
+            }
+            catch (error) {
+                consoleLogFormatted.error(error);
+                throw new Error(ERRORS.onBegin.failedToInitializeRun);
+            }
+            consoleLogFormatted.underline(MESSAGES.onBegin.testStarted);
+            consoleLogFormatted.dim(MESSAGES.onBegin.ciBuildId(this.ciBuildId));
+            if (shard) {
+                consoleLogFormatted.dim(MESSAGES.onBegin.totalShards(shard.total));
+                consoleLogFormatted.dim(MESSAGES.onBegin.currentShard(shard.current));
+            }
+            this.attempts = attempts;
+            this.config = config;
+            this.currentShard = shard === null || shard === void 0 ? void 0 : shard.current;
+        };
+        this.onTestBegin = async ({ id, title }, { retry }) => {
+            try {
+                const formData = new FormData();
+                formData.append("attempt[status]", "running");
+                retry === 0 &&
+                    (await attemptsApi.update(this.ciBuildId, id, this.attempts[id], formData));
+            }
+            catch (error) {
+                consoleLogFormatted.error(ERRORS.onTestBegin.failedToReportTest(title, id));
+                console.log(error);
+            }
+        };
+        this.onTestEnd = async ({ id, title }, { status, duration, errors, retry, attachments }) => {
+            try {
+                const testResult = {
+                    status,
+                    duration,
+                    log: errors.map(error => { var _a; return (_a = error.message) !== null && _a !== void 0 ? _a : ""; }).join("\n"),
+                };
+                consoleLogFormatted.underline(title);
+                const formData = new FormData();
+                attachments.map(({ name, path, body, contentType }) => {
+                    consoleLogFormatted.dim(`${name}: ${path}`);
+                    if (["screenshot", "video", "trace"].includes(name)) {
+                        const buffer = path ? require$$6.readFileSync(path) : body;
+                        formData.append(`attempt[${name}s][]`, convertBufferToBlob(buffer, contentType));
+                    }
+                });
+                Object.entries(testResult).map(([resultKey, resultValue]) => {
+                    formData.append(`attempt[${resultKey}]`, resultValue.toString());
+                });
+                retry === 0
+                    ? await attemptsApi.update(this.ciBuildId, id, this.attempts[id], formData)
+                    : await attemptsApi.create(this.ciBuildId, id, formData);
+            }
+            catch (error) {
+                consoleLogFormatted.error(ERRORS.onTestBegin.failedToReportTest(title, id));
+                console.log(error);
+            }
+        };
+        this.onEnd = async ({ status, duration }) => {
+            try {
+                await runsApi.update(this.ciBuildId, {
+                    shards: createShardObject({
+                        currentShard: this.currentShard,
+                        status,
+                        duration,
+                    }),
+                });
+            }
+            catch (error) {
+                console.log(error);
+                throw new Error(ERRORS.onEnd.failedToReportRunStatus);
+            }
         };
-        initializeAxios(options.applicationKey);
+        initializeAxios(options);
+        this.attempts = {};
+        this.ciBuildId = options.ciBuildId;
     }
 }