@mablhq/playwright-tools 2.49.1

package/upload/index.js.LICENSE.txt

@@ -0,0 +1,27 @@
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * MIT Licensed
+ */
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */

package/util/CloudStorageWriter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = require("@google-cloud/storage");
+const IdentifierUtil_1 = require("./IdentifierUtil");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const MAX_PUT_ATTEMPTS = 3;
+const AUTO_COMPRESS_MIME_TYPES = new Set([
+    'application/json',
+    'text/plain',
+]);
+class CloudStorageWriter {
+    constructor(projectId, workspaceId) {
+        this.bucket = new storage_1.Storage().bucket(`${projectId}-workspace-${(0, IdentifierUtil_1.toCloudSafeId)(workspaceId)}`);
+    }
+    bucketName() {
+        return this.bucket.name;
+    }
+    async write(path, contentType, data) {
+        let attempt = 0;
+        while (attempt++ < MAX_PUT_ATTEMPTS) {
+            try {
+                return await this.writeOnce(path, contentType, data);
+            }
+            catch (error) {
+                loggingProvider_1.logger.info(`Error writing file to GCS at ${path} (attempt ${attempt} of ${MAX_PUT_ATTEMPTS})`, error);
+                if (attempt === MAX_PUT_ATTEMPTS) {
+                    throw error;
+                }
+            }
+        }
+    }
+    writeOnce(path, contentType, data) {
+        return this.bucket.file(path).save(data, {
+            contentType,
+            metadata: {
+                'Content-Type': getNowIsoTimestamp(),
+            },
+            gzip: AUTO_COMPRESS_MIME_TYPES.has(contentType.toLowerCase()),
+        });
+    }
+}
+exports.default = CloudStorageWriter;
+function getNowIsoTimestamp() {
+    return new Date().toISOString();
+}

package/util/FileCache.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileCache = void 0;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const node_path_1 = require("node:path");
+const cachedir_1 = __importDefault(require("cachedir"));
+const upload_1 = require("../upload");
+const env_1 = require("../env/env");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const DEFAULT_READ_BUFFER_SIZE_BYTES = 8 * 1024 * 1024;
+class File {
+    constructor(directory, name) {
+        this.path = (0, node_path_1.resolve)((0, node_path_1.join)(directory, name));
+        this.stats = (0, fs_1.statSync)(this.path);
+    }
+    get createdTimeMillis() {
+        return this.stats.ctimeMs;
+    }
+    delete() {
+        (0, fs_1.rmSync)(this.path, { force: true, recursive: this.isDirectory });
+    }
+    get isDirectory() {
+        return this.stats.isDirectory();
+    }
+}
+class FileCache {
+    constructor({ cacheName, maximumCachedFiles, maximumCachedFileAgeMinutes, readBufferSizeBytes, }) {
+        this.cacheName = cacheName;
+        this.cacheDirectoryPath = (0, node_path_1.resolve)((0, node_path_1.join)((0, cachedir_1.default)(env_1.CONF_FILE_PROJECT_NAME), cacheName));
+        this.maximumCachedFiles = maximumCachedFiles;
+        this.maximumCachedFileAgeMinutes = maximumCachedFileAgeMinutes;
+        this.readBufferSizeBytes =
+            readBufferSizeBytes !== null && readBufferSizeBytes !== void 0 ? readBufferSizeBytes : DEFAULT_READ_BUFFER_SIZE_BYTES;
+    }
+    async performCacheCleanup() {
+        if (!(await this.directoryExists(this.cacheDirectoryPath))) {
+            return;
+        }
+        const nowMillis = Date.now();
+        try {
+            const files = (await (0, promises_1.readdir)(this.cacheDirectoryPath))
+                .map((name) => new File(this.cacheDirectoryPath, name))
+                .filter((file) => {
+                if (this.maximumCachedFileAgeMinutes &&
+                    (nowMillis - file.createdTimeMillis) / 1000 / 60 >
+                        this.maximumCachedFileAgeMinutes) {
+                    loggingProvider_1.logger.info(`Deleting expired cache ${file.isDirectory ? 'directory' : 'file'} ${file.path}`);
+                    file.delete();
+                    return false;
+                }
+                return true;
+            })
+                .sort((left, right) => right.createdTimeMillis - left.createdTimeMillis);
+            if (this.maximumCachedFiles && files.length > this.maximumCachedFiles) {
+                loggingProvider_1.logger.info(`Deleting the oldest ${files.length - this.maximumCachedFiles} file(s) in ${this.cacheName} cache`);
+                files.slice(this.maximumCachedFiles).forEach((file) => {
+                    loggingProvider_1.logger.info(`Deleting cache ${file.isDirectory ? 'directory' : 'file'} ${file.path}`);
+                    file.delete();
+                });
+            }
+        }
+        catch (error) {
+            loggingProvider_1.logger.error(`Error performing cache cleanup on ${this.cacheDirectoryPath}`, error);
+        }
+    }
+    async getOrCreateFile(name, getReader, metadata) {
+        const path = this.getCacheFilePath(name);
+        await this.performCacheCleanup();
+        if (await this.cachedFileIsValid(path, metadata)) {
+            return path;
+        }
+        const { crc32cHex: writtenCrc32cHex, sizeBytes: writtenSizeBytes } = await this.write(await getReader(), path, metadata === null || metadata === void 0 ? void 0 : metadata.sizeBytes);
+        if (metadata) {
+            if (writtenSizeBytes !== metadata.sizeBytes) {
+                throw new Error(`Expected ${metadata.sizeBytes}b but received ${writtenSizeBytes}b`);
+            }
+            if (writtenCrc32cHex !== metadata.crc32cHex) {
+                throw new Error(`Expected checksum ${metadata.crc32cHex} but computed ${writtenCrc32cHex}`);
+            }
+        }
+        if (!(await this.cachedFileIsValid(path, metadata))) {
+            throw new Error(`Downloaded cache file ${path} failed verification`);
+        }
+        return path;
+    }
+    async directoryExists(path) {
+        try {
+            return (await (0, promises_1.stat)(path)).isDirectory();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async fileExists(path) {
+        try {
+            return (await (0, promises_1.stat)(path)).isFile();
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async cachedFileIsValid(path, metadata) {
+        if (!(await this.fileExists(path))) {
+            return false;
+        }
+        if (metadata) {
+            loggingProvider_1.logger.info(`Verifying integrity of cache file ${path}`);
+            const actualSizeBytes = (await (0, promises_1.stat)(path)).size;
+            if (actualSizeBytes !== metadata.sizeBytes) {
+                loggingProvider_1.logger.warn(`Expected cache file at ${path} to have size [${metadata.sizeBytes}b] but was [${actualSizeBytes}b]`);
+                return false;
+            }
+            const actualCrc32cHex = await this.computeCrc32cHex(path);
+            if (actualCrc32cHex !== metadata.crc32cHex) {
+                loggingProvider_1.logger.warn(`Expected cache file at ${path} to have checksum [${metadata.crc32cHex}] but was [${actualCrc32cHex}]}`);
+                return false;
+            }
+        }
+        return true;
+    }
+    getCacheFilePath(relativePath) {
+        return (0, node_path_1.resolve)((0, node_path_1.join)(this.cacheDirectoryPath, relativePath));
+    }
+    async write(reader, destination, expectedSizeBytes) {
+        const destinationDirectory = (0, node_path_1.dirname)(destination);
+        if (!(await this.directoryExists(destinationDirectory))) {
+            await (0, promises_1.mkdir)(destinationDirectory, { recursive: true });
+        }
+        const fd = await (0, promises_1.open)(destination, 'w');
+        const writeStream = fd.createWriteStream({ autoClose: true });
+        const metadata = await new Promise((resolve, reject) => {
+            const crc32c = new upload_1.Crc32cChecksum();
+            let sizeBytes = 0;
+            let percentageComplete = 0;
+            writeStream.on('error', (error) => reject(error));
+            writeStream.on('close', () => resolve({ crc32cHex: crc32c.digestHex(), sizeBytes }));
+            reader.on('error', (error) => reject(error));
+            reader.on('end', () => writeStream.close());
+            reader.on('data', (chunk) => {
+                crc32c.update(chunk);
+                sizeBytes += chunk.byteLength;
+                if (expectedSizeBytes) {
+                    const newPercentageComplete = Math.round((sizeBytes / expectedSizeBytes) * 100);
+                    if (newPercentageComplete % 10 === 0 &&
+                        newPercentageComplete > percentageComplete) {
+                        percentageComplete = newPercentageComplete;
+                        loggingProvider_1.logger.info(`Downloaded ${sizeBytes} of ${expectedSizeBytes} bytes (${percentageComplete}% complete)`);
+                    }
+                }
+            });
+            reader.pipe(writeStream);
+        });
+        await this.performCacheCleanup();
+        return metadata;
+    }
+    async computeCrc32cHex(path) {
+        const fd = await (0, promises_1.open)(path, 'r');
+        const crc32c = new upload_1.Crc32cChecksum();
+        let totalBytesRead = 0;
+        while (true) {
+            const { buffer, bytesRead: chunkSizeBytes } = await fd.read({
+                buffer: Buffer.alloc(this.readBufferSizeBytes),
+                length: this.readBufferSizeBytes,
+                position: totalBytesRead,
+            });
+            if (chunkSizeBytes === 0) {
+                break;
+            }
+            totalBytesRead += chunkSizeBytes;
+            const chunk = buffer.subarray(0, chunkSizeBytes);
+            crc32c.update(chunk);
+        }
+        return crc32c.digestHex();
+    }
+}
+exports.FileCache = FileCache;

package/util/IdentifierUtil.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCloudSafeId = void 0;
+const legacyUuidPattern = /^[a-fA-F0-9-]{36}$/;
+const untypedUidPattern = /^[a-zA-Z0-9_-]+$/;
+const typedUidPattern = /^(?<id>[a-zA-Z0-9_-]{22})-(?<type>[a-z]+)$/;
+const idTypes = {
+    uuid: 1,
+    untypedUid: 2,
+    typedUid: 3,
+};
+function isLegacyUuid(id) {
+    return !!id.match(legacyUuidPattern);
+}
+function isUntypedUid(id) {
+    return !!id.match(untypedUidPattern);
+}
+function isTypedUid(id) {
+    return !!id.match(typedUidPattern);
+}
+function legacyUuidToHex(id) {
+    const idTypeBuffer = Buffer.alloc(1, idTypes.uuid);
+    const idBuffer = Buffer.from(id.toLowerCase().replace(/-/g, ''), 'hex');
+    return Buffer.concat([idTypeBuffer, idBuffer]).toString('hex');
+}
+function untypedUidToHex(id) {
+    const idTypeBuffer = Buffer.alloc(1, idTypes.untypedUid);
+    const idBuffer = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+    return Buffer.concat([idTypeBuffer, idBuffer]).toString('hex');
+}
+function typedUidToHex(typedUid) {
+    const { id, type } = typedUid.match(typedUidPattern)
+        .groups;
+    const idTypeBuffer = Buffer.alloc(1, idTypes.typedUid);
+    const idBuffer = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+    const typeBuffer = Buffer.from(type, 'utf8');
+    return Buffer.concat([idTypeBuffer, idBuffer, typeBuffer]).toString('hex');
+}
+function hexToBase36(hex) {
+    return BigInt(`0x${hex}`).toString(36);
+}
+function toCloudSafeId(id) {
+    if (!id) {
+        throw new Error('id is required');
+    }
+    if (isLegacyUuid(id)) {
+        return hexToBase36(legacyUuidToHex(id));
+    }
+    if (isTypedUid(id)) {
+        return hexToBase36(typedUidToHex(id));
+    }
+    if (isUntypedUid(id)) {
+        return hexToBase36(untypedUidToHex(id));
+    }
+    throw new Error(`Not a valid ID: [${id}]`);
+}
+exports.toCloudSafeId = toCloudSafeId;

package/util/InternalMetricsTrackingSingleton.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalMetricsTrackingSingleton = void 0;
+const logUtils_1 = require("./logUtils");
+class InternalMetricsTrackingSingleton {
+    constructor() {
+        this.metadata = {};
+    }
+    static getInstance() {
+        if (!InternalMetricsTrackingSingleton.instance) {
+            InternalMetricsTrackingSingleton.instance =
+                new InternalMetricsTrackingSingleton();
+        }
+        return InternalMetricsTrackingSingleton.instance;
+    }
+    addMetric(name, value) {
+        this.metadata[name] = value;
+    }
+    addMetrics(metrics) {
+        this.metadata = { ...this.metadata, ...metrics };
+    }
+    testType(testType) {
+        this.metadata.testType = testType;
+    }
+    testStatus(testStatus) {
+        this.metadata.testStatus = testStatus;
+    }
+    reportMetrics() {
+        if (Object.keys(this.metadata).length === 0) {
+            return;
+        }
+        (0, logUtils_1.logInternal)('Internal metrics:', this.metadata);
+        this.metadata = {};
+    }
+}
+exports.InternalMetricsTrackingSingleton = InternalMetricsTrackingSingleton;

package/util/Lazy.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Lazy = void 0;
+class Lazy {
+    constructor(initializer) {
+        this.initializer = initializer;
+    }
+    apply(action) {
+        return action(this.instance);
+    }
+    get instance() {
+        if (!this.value) {
+            this.value = this.initializer();
+        }
+        return this.value;
+    }
+    get isInitialized() {
+        return !!this.value;
+    }
+    map(mapper) {
+        return new Lazy(() => this.apply(mapper));
+    }
+    get maybe() {
+        return this.value;
+    }
+    reset() {
+        this.value = undefined;
+    }
+    withValue(consumer) {
+        consumer(this.instance);
+    }
+    withValueAsync(consumer) {
+        return this.apply(consumer);
+    }
+    static from(instance) {
+        return new Lazy(() => instance);
+    }
+    static of(initializer) {
+        return new Lazy(initializer);
+    }
+    static proxy(initializer) {
+        const lazy = Lazy.of(initializer);
+        return new Proxy(lazy, new LazyProxy(lazy));
+    }
+}
+exports.Lazy = Lazy;
+class LazyProxy {
+    constructor(lazy) {
+        this.lazy = lazy;
+    }
+    apply(target, _thisArg, args) {
+        return Reflect.apply(target, this.lazy.instance, args);
+    }
+    construct(target, argArray, _newTarget) {
+        return Reflect.construct(target, argArray, this.lazy.instance.constructor);
+    }
+    defineProperty(_target, property, attributes) {
+        return Reflect.defineProperty(this.lazy.instance, property, attributes);
+    }
+    deleteProperty(_target, p) {
+        return Reflect.deleteProperty(this.lazy.instance, p);
+    }
+    get(_target, p, receiver) {
+        return Reflect.get(this.lazy.instance, p, receiver);
+    }
+    getOwnPropertyDescriptor(_target, p) {
+        return Reflect.getOwnPropertyDescriptor(this.lazy.instance, p);
+    }
+    getPrototypeOf(_target) {
+        return Reflect.getPrototypeOf(this.lazy.instance);
+    }
+    has(_target, p) {
+        return Reflect.has(this.lazy.instance, p);
+    }
+    isExtensible(_target) {
+        return Reflect.isExtensible(this.lazy.instance);
+    }
+    ownKeys(_target) {
+        return Reflect.ownKeys(this.lazy.instance);
+    }
+    preventExtensions(_target) {
+        return Reflect.preventExtensions(this.lazy.instance);
+    }
+    set(_target, p, newValue, receiver) {
+        return Reflect.set(this.lazy.instance, p, newValue, receiver);
+    }
+    setPrototypeOf(_target, v) {
+        return Reflect.setPrototypeOf(this.lazy.instance, v);
+    }
+}

package/util/MobileAppFileCache.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileAppFileCache = void 0;
+const path_1 = require("path");
+const stream_1 = require("stream");
+const promises_1 = require("fs/promises");
+const mablApi_1 = require("../mablApi");
+const util_1 = require("../core/util");
+const FileCache_1 = require("./FileCache");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const MOBILE_APP_FILE_CACHE_DIRECTORY = 'mobile-app-files';
+const DEFAULT_MAX_MOBILE_APP_FILES = 10;
+const DEFAULT_MAX_MOBILE_APP_FILE_AGE_MINUTES = 60 * 24;
+const MOBILE_APP_FILE_IMMUTABLE_FIELDS = [
+    'content_type',
+    'crc32c_hex',
+    'created_by_id',
+    'created_time',
+    'extension',
+    'id',
+    'name',
+    'platform',
+    'size',
+    'version',
+    'workspace_id',
+];
+const MOBILE_APP_FILE_IMMUTABLE_FIELD_SET = new Set(MOBILE_APP_FILE_IMMUTABLE_FIELDS);
+class MobileAppFileCache extends FileCache_1.FileCache {
+    constructor(options) {
+        var _a, _b;
+        super({
+            ...options,
+            cacheName: MOBILE_APP_FILE_CACHE_DIRECTORY,
+            maximumCachedFiles: (_a = options === null || options === void 0 ? void 0 : options.maximumCachedFiles) !== null && _a !== void 0 ? _a : DEFAULT_MAX_MOBILE_APP_FILES,
+            maximumCachedFileAgeMinutes: (_b = options === null || options === void 0 ? void 0 : options.maximumCachedFileAgeMinutes) !== null && _b !== void 0 ? _b : DEFAULT_MAX_MOBILE_APP_FILE_AGE_MINUTES,
+        });
+        this.mablApiClientPromise = (options === null || options === void 0 ? void 0 : options.mablApiClient)
+            ? Promise.resolve(options.mablApiClient)
+            : (0, util_1.getApiClient)();
+    }
+    async getMobileAppFileImmutableFields(id) {
+        const getReader = async () => {
+            const apiClient = await this.mablApiClientPromise;
+            const mobileAppFile = this.retainImmutableFields(await apiClient.getMobileAppFile(id));
+            return stream_1.Readable.from(Buffer.from(JSON.stringify(mobileAppFile, undefined, 0), 'utf-8'));
+        };
+        const path = await this.getOrCreateFile((0, path_1.join)(id, 'MobileAppFile.json'), getReader);
+        return JSON.parse((await (0, promises_1.readFile)(path)).toString());
+    }
+    async getMobileAppFile(id) {
+        const mobileAppFile = await this.getMobileAppFileImmutableFields(id);
+        const { crc32c_hex: crc32cHex, size: sizeBytes } = mobileAppFile;
+        const getReader = async () => {
+            loggingProvider_1.logger.info(`Downloading mobile app file ${id}`);
+            const apiClient = await this.mablApiClientPromise;
+            const { download_url: downloadUrl } = await apiClient.getMobileAppFile(id, true);
+            return (await apiClient.httpClient.get(downloadUrl, {
+                responseType: 'stream',
+            })).data;
+        };
+        const extension = this.getMobileAppFileExtension(mobileAppFile);
+        if (!extension) {
+            throw new Error(`Unable to determine file extension for mobile app file ${id}`);
+        }
+        const path = await this.getOrCreateFile((0, path_1.join)(id, `MobileAppFile.${extension}`), getReader, {
+            crc32cHex: crc32cHex,
+            sizeBytes: sizeBytes,
+        });
+        return { ...mobileAppFile, path };
+    }
+    retainImmutableFields(mobileAppFile) {
+        const immutableFields = { ...mobileAppFile };
+        Object.keys(immutableFields).forEach((field) => {
+            if (!MOBILE_APP_FILE_IMMUTABLE_FIELD_SET.has(field)) {
+                delete immutableFields[field];
+            }
+        });
+        return immutableFields;
+    }
+    getMobileAppFileExtension({ extension, id, name, platform, }) {
+        let resolvedExtension = extension;
+        if (!resolvedExtension && name) {
+            resolvedExtension = (0, path_1.extname)(name);
+        }
+        if (!resolvedExtension && platform) {
+            switch (platform) {
+                case mablApi_1.MobilePlatformEnum.Android:
+                    resolvedExtension = 'apk';
+                    break;
+                case mablApi_1.MobilePlatformEnum.Ios:
+                    resolvedExtension = 'app.zip';
+                    break;
+                default:
+                    throw new Error(`Mobile app file ${id} has unknown platform ${platform}`);
+            }
+        }
+        if (resolvedExtension === null || resolvedExtension === void 0 ? void 0 : resolvedExtension.startsWith('.')) {
+            resolvedExtension = resolvedExtension.substring(1);
+        }
+        return resolvedExtension;
+    }
+}
+exports.MobileAppFileCache = MobileAppFileCache;

package/util/RichPromise.js

@@ -0,0 +1,53 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+class RichPromise {
+    constructor(chained) {
+        this.resolver = () => { };
+        this.resolved = false;
+        this.rejecter = () => { };
+        this.rejected = false;
+        this[_a] = 'promise';
+        this.promise = new Promise((resolve, reject) => {
+            this.resolver = resolve;
+            this.rejecter = reject;
+        });
+        if (chained) {
+            chained
+                .then((result) => this.resolve(result))
+                .catch((reason) => this.reject(reason));
+        }
+    }
+    isPending() {
+        return !(this.isResolved() || this.isRejected());
+    }
+    resolve(value) {
+        if (this.isPending()) {
+            this.resolver(value);
+            this.resolved = true;
+        }
+    }
+    isResolved() {
+        return this.resolved;
+    }
+    reject(reason) {
+        if (this.isPending()) {
+            this.rejecter(reason);
+            this.rejected = true;
+        }
+    }
+    isRejected() {
+        return this.rejected;
+    }
+    then(onfulfilled, onrejected) {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.promise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.promise.finally(onfinally);
+    }
+}
+_a = Symbol.toStringTag;
+exports.default = RichPromise;