@apica-io/asm-playwright-runner 1.0.0-dev.1

package/src/lib/parser.ts

@@ -0,0 +1,341 @@
+import unzipper from 'unzipper';
+import archiver from "archiver";
+import {Action, HookAction, StackFrame, TraceModel} from "../model/traceModel";
+import path from "path";
+import fs from "fs";
+import {LogLevel, ResultDir} from "../model/runnerConfig";
+
+export async function getJsonFileData(tracePath: string, fileName: string): Promise<Record<string, any>> {
+    const directory = await unzipper.Open.file(tracePath);
+
+    const file = directory.files.find(
+        f => f.path.endsWith(fileName)
+    );
+
+    if (!file) {
+        return {}
+    }
+
+    const content = await file.buffer();
+    return JSON.parse(content.toString("utf-8"));
+}
+
+export async function getFileData(tracePath: string, fileName: string): Promise<string[]> {
+    const directory = await unzipper.Open.file(tracePath);
+
+    const traceFile = directory.files.find(f => f.path.endsWith(fileName));
+    if (!traceFile) {
+        return [];
+    }
+
+    const content = await traceFile.buffer();
+    return content.toString('utf-8').split('\n').filter(Boolean);
+}
+
+async function extractResources(
+    zipPath: string,
+    targetImages: string[] = []
+) {
+    const baseDir = path.dirname(zipPath);
+    const runName = path.basename(baseDir);
+    const resultDir = path.dirname(baseDir);
+
+    const parentDir = resultDir === "." ? runName : resultDir;
+    const appendRunName = resultDir === "." ? [] : [runName];
+
+    const screenshotsDir = path.join(
+        parentDir, ResultDir.SCREENSHOT, ...appendRunName
+    );
+
+    const sourceDir = path.join(
+        parentDir, ResultDir.SOURCE, ...appendRunName
+    );
+
+    // Create folders if not exists
+    [screenshotsDir, sourceDir].forEach(dir => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, {recursive: true});
+        }
+    });
+
+    const directory = await unzipper.Open.file(zipPath);
+
+    // Copy target images
+    const imagePromises = targetImages.map(targetImage => {
+        const fileEntry = directory.files.find(
+            (file: { path: string; }) => file.path === `resources/${targetImage}`
+        );
+
+        if (!fileEntry) {
+            return Promise.resolve();
+        }
+
+        const outputPath = path.join(
+            screenshotsDir, targetImage
+        );
+
+        return new Promise((resolve, reject) => {
+            fileEntry
+                .stream()
+                .pipe(fs.createWriteStream(outputPath))
+                .on('finish', () => {
+                    resolve(true);
+                })
+                .on('error', reject);
+        });
+    });
+
+    // Copy all src@*.txt files
+    const sourcePromises = directory.files
+        .filter(
+            file =>
+                file.path.startsWith('resources/') &&
+                /^src@.*\.txt$/.test(path.basename(file.path))
+        )
+        .map(fileEntry => {
+            const fileName = path.basename(fileEntry.path);
+            const outputPath = path.join(sourceDir, fileName);
+
+            return new Promise((resolve, reject) => {
+                fileEntry
+                    .stream()
+                    .pipe(fs.createWriteStream(outputPath))
+                    .on('finish', () => {
+                        resolve(true);
+                    })
+                    .on('error', reject);
+            });
+        });
+
+    await Promise.all([...imagePromises, ...sourcePromises]);
+}
+
+export async function zipResources(outputZipPath: string, screenshotsDir: string, sourceDir: string) {
+    return new Promise<void>((resolve, reject) => {
+        const output = fs.createWriteStream(outputZipPath);
+        const archive = archiver("zip", { zlib: { level: 9 } });
+
+        output.on("close", resolve);
+        archive.on("error", reject);
+
+        archive.pipe(output);
+
+        if (fs.existsSync(screenshotsDir)) {
+            archive.directory(screenshotsDir, ResultDir.SCREENSHOT);
+        }
+
+        if (fs.existsSync(sourceDir)) {
+            archive.directory(sourceDir, ResultDir.SOURCE);
+        }
+
+        archive.finalize();
+    });
+}
+
+export async function setHookActions(traceRawResult: string[]): Promise<TraceModel> {
+    const hookModel: TraceModel = {actions: [], stdio: []};
+    const hookActions: Record<string, HookAction> = {};
+
+    for (const [index, row] of traceRawResult.entries()) {
+        const entry = JSON.parse(row);
+
+        if (entry.type === "context-options") {
+            Object.assign(hookModel, {
+                origin: entry.origin,
+                browserName: entry.browserName,
+                playwrightVersion: entry.playwrightVersion,
+                options: entry.options,
+                platform: entry.platform,
+                wallTime: entry.wallTime,
+                startTime: entry.monotonicTime,
+                sdkLanguage: entry.sdkLanguage,
+                testIdAttributeName: entry.testIdAttributeName,
+                contextId: entry.contextId,
+                testTimeout: entry.testTimeout,
+            });
+            continue;
+        } else if (entry.type === "stdout") {
+            hookModel?.stdio?.push(entry)
+        } else if (entry.type === "before") {
+            const action: HookAction = {
+                type: "action",
+                callId: entry.callId,
+                stepId: entry.stepId,
+                parentId: entry.parentId,
+                startTime: entry.startTime,
+                class: entry.class,
+                method: entry.method,
+                title: entry.title,
+                params: entry.params,
+                stack: entry.stack,
+                log: [],
+            };
+            hookActions[entry.callId] = action;
+            hookModel.actions!.push(action);
+        } else if (entry.type === "after" && hookActions[entry.callId]) {
+            Object.assign(hookActions[entry.callId], {
+                endTime: entry.endTime,
+                annotations: entry.annotations,
+            });
+        }
+
+        if (index === (traceRawResult.length - 1) && entry.type === "after") {
+            hookModel.endTime = entry.endTime;
+        }
+    }
+
+    return hookModel;
+}
+
+
+export async function setActions(traceRawResult: string[], traceModel: TraceModel, tracePath: string, stackData: Record<string, any>) {
+    let beforeFlag = false
+    let action: Action | null = null;
+    let targetImages: string[] = [];
+
+    for (const row of traceRawResult) {
+        const entry = JSON.parse(row);
+        if (entry.type === 'context-options') {
+            traceModel.origin = entry.origin;
+            traceModel.browserName = entry.browserName;
+            traceModel.playwrightVersion = entry.playwrightVersion;
+            traceModel.options = entry.options;
+            traceModel.platform = entry.platform;
+            traceModel.wallTime = entry.wallTime;
+            traceModel.startTime = entry.monotonicTime;
+            traceModel.sdkLanguage = entry.sdkLanguage;
+            traceModel.testIdAttributeName = entry.testIdAttributeName;
+            traceModel.contextId = entry.contextId;
+        } else if (entry.type == "event" || entry.type == "console") {
+            traceModel.events?.push(entry);
+        } else if (entry.type == "screencast-frame") {
+            let page = traceModel.pages?.find(
+                p => p.pageId === entry.pageId
+            );
+
+            if (!page) {
+                page = {
+                    pageId: entry.pageId,
+                    screencastFrames: [],
+                };
+
+                traceModel.pages?.push(page);
+            }
+            targetImages.push(entry.sha1);
+            page.screencastFrames.push(entry);
+        } else {
+            if (entry.type == "before") {
+                action = {
+                    callId: entry.callId,
+                    class: entry.class,
+                    method: entry.method,
+                    startTime: entry.startTime,
+                    type: "action",
+                    params: entry.params,
+                    pageId: entry.pageId,
+                    log: [],
+                    stack: stackData[entry.callId]
+                }
+
+                if (entry.class == "Frame") {
+                    action.beforeSnapshot = entry.beforeSnapshot
+                }
+
+                beforeFlag = true
+            }
+
+            if (beforeFlag && action != null && action.callId == entry.callId) {
+                if (entry.type == "log") {
+                    action.log?.push({
+                        time: entry.time,
+                        message: entry.message
+                    })
+                }
+
+                if (entry.type == "after") {
+                    beforeFlag = false
+                    action.endTime = entry.endTime;
+                    action.result = entry.result;
+                    action.error = entry.error;
+                    action.afterSnapshot = entry.afterSnapshot
+                    traceModel.actions?.push(action);
+                }
+            }
+        }
+    }
+
+    traceModel.endTime = action?.endTime
+    await extractResources(tracePath, targetImages)
+}
+
+export async function setResources(resourceRawResult: string[], traceModel: TraceModel) {
+    for (const row of resourceRawResult) {
+        const entry = JSON.parse(row);
+        traceModel.resources?.push(entry.snapshot);
+    }
+}
+
+interface PreparedStackData {
+    [key: string]: StackFrame[];
+}
+
+export async function prepareStackData(stacksRawResult: Record<string, any>): Promise<PreparedStackData> {
+    const preparedData: PreparedStackData = {};
+    const files: string[] = stacksRawResult.files || [];
+    const stacks = stacksRawResult.stacks || [];
+
+    for (const stack of stacks) {
+        const [callId, frames] = stack;
+        preparedData[`call@${callId}`] = frames.map(
+            ([fileIndex, line, column, fn]: [number, number, number, string]) => ({
+                file: files[fileIndex] || `source-file-${fileIndex}`,
+                fileIndex: `source-file-${fileIndex}`,
+                line,
+                column,
+                functionName: fn || ""
+            })
+        );
+    }
+
+    return preparedData;
+}
+
+export async function prepareTraceModel(tracePath: string, logLevel: LogLevel | undefined): Promise<TraceModel[]> {
+    const traceRawResult = await getFileData(tracePath, "trace.trace");
+    const resourceRawResult = await getFileData(tracePath, "trace.network");
+    const stacksRawResult = await getJsonFileData(tracePath, "trace.stacks")
+    const traceModel: TraceModel = {
+        actions: [],
+        events: [],
+        resources: [],
+        errors: [],
+        pages: []
+    };
+
+    if (logLevel == LogLevel.DEBUG) {
+        fs.writeFileSync(
+            path.join(path.dirname(tracePath), "trace-raw-data.json"),
+            JSON.stringify(traceRawResult, null, 2), "utf-8"
+        );
+    }
+
+    const stackData = await prepareStackData(stacksRawResult);
+    await setActions(traceRawResult, traceModel, tracePath, stackData);
+    await setResources(resourceRawResult, traceModel);
+
+    const testHookResult = await getFileData(tracePath, "test.trace");
+    if (testHookResult && testHookResult.length > 0) {
+        if (logLevel == LogLevel.DEBUG) {
+            //raw data to validate data from trace
+            fs.writeFileSync(
+                path.join(path.dirname(tracePath), "test-trace-raw-data.json"),
+                JSON.stringify(testHookResult, null, 2), "utf-8"
+            );
+        }
+
+        const hookModel = await setHookActions(testHookResult)
+        return [hookModel, traceModel]
+    }
+
+    return [traceModel];
+}

package/src/model/runnerConfig.ts

@@ -0,0 +1,41 @@
+export interface RunnerConfig {
+    browser: BrowserType;
+    chromiumPath?: string;
+    headless: boolean;
+    verbose: boolean;
+    resultDir: string;
+    logLevel: LogLevel;
+    trace?: string;
+    returnResult: boolean
+    sslClientCert?: string;
+    sslClientKey?: string;
+    sslClientPassphrase?: string;
+    isValidScript?: boolean;
+    scriptType?: ScriptType;
+    extraHTTPHeaders?: string;
+    timeout?: number;
+}
+
+export enum BrowserType {
+    CHROMIUM = "chromium",
+    FIREFOX = "firefox",
+    WEBKIT = "webkit"
+}
+
+export enum LogLevel {
+    INFO = "info",
+    DEBUG = "debug",
+    ERROR = "error"
+}
+
+export enum ScriptType {
+    JSON = "json",
+    PLAYWRIGHT = "playwright",
+    PLAYWRIGHT_TEST = "playwright/test"
+}
+
+export enum ResultDir {
+    BASE_DIR = "result",
+    SCREENSHOT = "screenshots",
+    SOURCE = "source"
+}

package/src/model/traceModel.ts

@@ -0,0 +1,150 @@
+export interface TraceModel {
+    actions?: Action[];
+    browserName?: string;
+    contextId?: string;
+    endTime?: number;
+    events?: Event[];
+    hasSource?: boolean;
+    options?: BrowserContextOptions;
+    origin?: string;
+    pages?: Page[];
+    platform?: string;
+    playwrightVersion?: string;
+    resources?: Resource[];
+    sdkLanguage?: string;
+    startTime?: number;
+    testIdAttributeName?: string;
+    wallTime?: number;
+    stdio?: Record<string, any>[];
+
+    // this is for hook test model
+    testTimeout?: number
+
+    errors?: [];
+}
+
+export interface Resource {
+    cache: Record<string, any>;
+    pageref: string;
+    request: Request;
+    response: Response;
+    serverIPAddress: string;
+    startedDateTime: string;
+    time: number;
+    timings: Timing;
+    _frameref: string;
+    _monotonicTime: number;
+    _securityDetails: Record<string, any>;
+    _serverPort: number
+}
+
+export interface Timing {
+    connect: number;
+    dns: number;
+    receive: number;
+    send: number;
+    ssl: number;
+    wait: number;
+}
+
+export interface Response {
+    bodySize: number;
+    content: Record<string, any>;
+    cookies: string[];
+    headers: Record<string, any>;
+    headersSize: number;
+    httpVersion: string;
+    redirectURL: string;
+    status: number;
+    statusText: string;
+    _transferSize: number;
+}
+
+export interface Request {
+    bodySize: number;
+    cookies: string[];
+    headers: Record<string, any>;
+    headersSize: number;
+    httpVersion: string;
+    method: string;
+    queryString: string[];
+    url: string;
+}
+
+export interface Page {
+    pageId: string;
+    screencastFrames: ScreencastFrame[]
+}
+
+export interface ScreencastFrame {
+    frameSwapWallTime: number;
+    height: number;
+    pageId: string;
+    sha1: string;
+    timestamp: number;
+    type: string;
+    width: number;
+}
+
+export interface Event {
+    class: string;
+    method: string;
+    params: Record<string, any>;
+    time: number;
+    type: 'event';
+}
+
+export type TraceEventType =
+    | 'context-options'
+    | 'before'
+    | 'after'
+    | 'event';
+
+export interface BrowserContextOptions {
+    noDefaultViewport?: boolean;
+    ignoreHTTPSErrors?: boolean;
+    selectorEngines?: any[];
+    acceptDownloads?: string;
+    viewport?: Viewport;
+}
+
+export interface HookAction extends Action{
+    stepId?: string;
+    annotations?: [];
+    title?: string;
+    parentId?: string;
+}
+
+export interface Action {
+    type: 'action';
+    callId: string;
+    startTime: number;
+    endTime?: number;
+    class: string;
+    method: string;
+    params?: Record<string, any>;
+    pageId?: string;
+    beforeSnapshot?: string;
+    afterSnapshot?: string;
+    log?: ActionLog[];
+    result?: Record<string, any>;
+    stack?: StackFrame[];
+    error?: Record<string, any>;
+}
+
+export interface ActionLog {
+    time: number;
+    message: string;
+}
+
+export interface StackFrame {
+    file: string;
+    line: number;
+    column: number;
+    function: string;
+}
+
+export interface Viewport {
+    width: number;
+    height: number;
+}