@bigbinary/neeto-playwright-reporter 1.2.0 → 1.3.0

package/index.d.ts

@@ -6,14 +6,18 @@ interface ReporterOptionParams {
     ciBuildId: string;
 }
 declare class MyReporter implements Reporter {
-    attempts: Record<string, string>;
+    attempts: Record<string, Record<string, string>>;
     ciBuildId: string;
     config: FullConfig | undefined;
     currentShard: number | undefined;
+    retryAttemptStartedAt: Date;
+    testResultCalls: Promise<unknown>[];
+    totalTestCount: number;
+    reportedTestCount: number;
     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>;
+    onTestEnd: (testCase: TestCase, { status, duration, errors, retry, attachments }: TestResult) => Promise<void>;
     onEnd: ({ status, duration }: FullResult) => Promise<void>;
 }
 

package/index.js

@@ -11,6 +11,7 @@ import require$$0$2 from 'os';
 import zlib from 'zlib';
 import EventEmitter from 'events';
 import childProcess from 'child_process';
+import crypto from 'crypto';
 
 function bind(fn, thisArg) {
   return function wrap() {
@@ -18439,13 +18440,19 @@ const HEADERS_KEYS = {
 };
 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 create$2 = (ciBuildId, history_id, payload) => axios.post(`${API_BASE_URL}/reporter/runs/${ciBuildId}/test_entities/${history_id}/attempts`, payload);
+const update$1 = (ciBuildId, history_id, id, payload) => axios.put(`${API_BASE_URL}/reporter/runs/${ciBuildId}/test_entities/${history_id}/attempts/${id}`, payload);
 const attemptsApi = { create: create$2, update: update$1 };
 
+const getDirectUploadURL = (payload) => axios.post(`${API_BASE_URL}/reporter/direct_uploads`, {
+    blob: payload,
+});
+const uploadToS3 = (data, { url, headers }) => axios.put(url, data, { headers });
+
 const ERRORS = {
     onBegin: {
         failedToGetCommitSha: "Failed to get current commit SHA.",
+        failedToGetBranch: "Failed to get current branch.",
         failedToGetCommitMessage: "Failed to get current commit message.",
         failedToInitializeRun: "Failed to initialize run in reporter",
     },
@@ -18501,7 +18508,13 @@ const executeCommandLine = ({ command, messageOnError, shouldThrowError = false,
 const createShardObject = ({ currentShard = 0, status = "running", duration = null, }) => ({
     [currentShard]: { status, duration },
 });
-const convertBufferToBlob = (buffer, contentType) => new Blob([buffer], { type: contentType });
+const waitUntilTimeout = (timeout) => new Promise(resolve => setTimeout(resolve, timeout));
+
+const getFileData = (file, contentType, filename) => {
+    const byte_size = file.byteLength;
+    const checksum = crypto.createHash("md5").update(file).digest("base64");
+    return { file, filename, checksum, byte_size, content_type: contentType };
+};
 
 const create$1 = (payload) => axios.post(`${API_BASE_URL}/reporter/runs`, {
     run: payload,
@@ -18521,6 +18534,10 @@ const getCurrentCommitMessage = () => executeCommandLine({
     command: "git show-branch --no-name HEAD",
     messageOnError: ERRORS.onBegin.failedToGetCommitMessage,
 });
+const getCurrentBranch = () => executeCommandLine({
+    command: "git branch --show-current",
+    messageOnError: ERRORS.onBegin.failedToGetBranch,
+});
 const getInitializerData = ({ rootDir }, rootSuite) => rootSuite.allTests().map(test => {
     var _a;
     const { title, parent, id: history_id, location: { file }, } = test;
@@ -18565,10 +18582,12 @@ class MyReporter {
         this.onBegin = async (config, rootSuite) => {
             const shard = config.shard;
             let attempts;
+            this.totalTestCount = rootSuite.allTests().length;
             try {
                 const runDetails = {
                     commit_id: getCurrentCommitSha(),
                     commit_name: getCurrentCommitMessage(),
+                    branch: getCurrentBranch(),
                     ci_build_id: this.ciBuildId,
                     configuration: config,
                     shards: createShardObject({ currentShard: shard === null || shard === void 0 ? void 0 : shard.current }),
@@ -18597,47 +18616,82 @@ class MyReporter {
         this.onTestBegin = async ({ id, title }, { retry }) => {
             consoleLogFormatted.invertBackground(MESSAGES.onTestBegin.startingTest(title));
             try {
-                const formData = new FormData();
-                formData.append("attempt[status]", "running");
-                retry === 0 &&
-                    (await attemptsApi.update(this.ciBuildId, id, this.attempts[id], formData));
+                this.retryAttemptStartedAt = new Date();
+                while (!this.attempts[id]["0"])
+                    await waitUntilTimeout(100); // Poll every 100 milliseconds
+                if (retry === 0) {
+                    await attemptsApi.update(this.ciBuildId, id, this.attempts[id]["0"], {
+                        status: "running",
+                        started_at: new Date().toString(),
+                    });
+                }
+                else {
+                    const { data: { history_id, attempt_id }, } = await attemptsApi.create(this.ciBuildId, id, {
+                        status: "running",
+                        started_at: new Date().toString(),
+                    });
+                    this.attempts = {
+                        ...this.attempts,
+                        [history_id]: {
+                            ...this.attempts[history_id],
+                            [String(retry)]: attempt_id,
+                        },
+                    };
+                }
             }
             catch (error) {
                 consoleLogFormatted.error(error.message);
                 consoleLogFormatted.error(ERRORS.onTestBegin.failedToReportTest(title, id));
             }
         };
-        this.onTestEnd = async ({ id, title }, { status, duration, errors, retry, attachments }) => {
+        this.onTestEnd = async (testCase, { status, duration, errors, retry, attachments }) => {
+            const completedAt = new Date();
+            const { id, title, expectedStatus } = testCase;
             try {
                 const testResult = {
+                    outcome: testCase.outcome(),
+                    expected_status: expectedStatus,
                     status,
                     duration,
                     log: errors.map(error => { var _a; return (_a = error.message) !== null && _a !== void 0 ? _a : ""; }).join("\n"),
+                    screenshots: [],
+                    videos: [],
+                    traces: [],
+                    completed_at: completedAt.toString(),
                 };
                 consoleLogFormatted.underline(title);
-                const formData = new FormData();
-                attachments.map(({ name, path, body, contentType }) => {
+                await Promise.all(attachments.map(async ({ 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));
+                        const fileName = path
+                            ? path.split("/").slice(-1)[0]
+                            : `${name}.${contentType.split("/").slice(-1)[0]}`;
+                        const { file, ...metadata } = getFileData(buffer, contentType, fileName);
+                        const { data: { signed_id, direct_upload }, } = await getDirectUploadURL(metadata);
+                        const pluralizedAsset = `${name}s`;
+                        testResult[pluralizedAsset].push(signed_id);
+                        return uploadToS3(file, direct_upload);
                     }
-                });
-                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);
+                }));
+                while (!this.attempts[id][retry])
+                    await waitUntilTimeout(100);
+                this.testResultCalls.push(attemptsApi.update(this.ciBuildId, id, this.attempts[id][retry], testResult));
                 consoleLogFormatted.invertBackground(MESSAGES.onTestEnd.reportedTest(title));
             }
             catch (error) {
                 consoleLogFormatted.error(error.message);
                 consoleLogFormatted.error(ERRORS.onTestBegin.failedToReportTest(title, id));
             }
+            finally {
+                retry === 0 && this.reportedTestCount++;
+            }
         };
         this.onEnd = async ({ status, duration }) => {
             try {
+                await Promise.allSettled(this.testResultCalls);
+                while (this.totalTestCount !== this.reportedTestCount)
+                    await waitUntilTimeout(100);
                 await runsApi.update(this.ciBuildId, {
                     shards: createShardObject({
                         currentShard: this.currentShard,
@@ -18654,6 +18708,10 @@ class MyReporter {
         initializeAxios(options);
         this.attempts = {};
         this.ciBuildId = options.ciBuildId;
+        this.retryAttemptStartedAt = new Date();
+        this.testResultCalls = [];
+        this.totalTestCount = 0;
+        this.reportedTestCount = 0;
     }
 }