@testrigor/testrigor-cli 0.0.44-beta → 0.0.45-beta

package/dist/commands/test-suite/run.d.ts

@@ -38,6 +38,8 @@ export default class Run extends CommandBase<typeof Run> {
     run(): Promise<void>;
     private fetchStatus;
     private getStatusApiEndpoint;
+    private uploadVariableFiles;
+    private uploadClientCertificates;
     private callRetest;
     private fetchSuiteType;
     private isMobileSuiteType;

package/dist/commands/test-suite/run.js

@@ -11,6 +11,9 @@ const chrome_extension_1 = require("../../flags/chrome-extension");
 const parser_1 = require("../../util/parser");
 const request_builder_1 = require("../../util/request-builder");
 const tunnel_1 = require("../../util/tunnel");
+const certificate_uploader_1 = require("../../util/certificate-uploader");
+const variable_file_uploader_1 = require("../../util/variable-file-uploader");
+const variables_path_parser_1 = require("../../util/variables-path-parser");
 const appium_1 = require("../../util/appium");
 const utils_1 = require("../../util/utils");
 const sleep = async (milliseconds) => {
@@ -118,10 +121,23 @@ class Run extends command_base_1.CommandBase {
         if (variablesPath) {
             try {
                 const file = await Fs.content(variablesPath);
-                context.configuration.storedValues = JSON.parse(file.toString());
+                const parsed = JSON.parse(file.toString());
+                const { textValues, fileInputs, certInputs } = (0, variables_path_parser_1.parseVariablesJson)(parsed);
+                context.configuration.storedValues = textValues;
+                if (fileInputs.length > 0) {
+                    context.storedValueFileInputs = fileInputs;
+                }
+                if (certInputs.length > 0) {
+                    context.storedValueCertInputs = certInputs;
+                }
             }
             catch (e) {
-                core_1.ux.error("--variables-path must be a valid JSON path");
+                if (e instanceof SyntaxError) {
+                    core_1.ux.error("--variables-path must be a valid JSON path");
+                }
+                else {
+                    core_1.ux.error(e instanceof Error ? e.message : String(e));
+                }
             }
         }
         if (testCasesPath) {
@@ -293,6 +309,18 @@ class Run extends command_base_1.CommandBase {
                         },
                         exitOnError: false,
                     },
+                    {
+                        title: "Uploading variable files",
+                        enabled: () => !!context.storedValueFileInputs?.length,
+                        task: (ctx) => this.uploadVariableFiles(ctx, testSuiteId, token),
+                        exitOnError: false,
+                    },
+                    {
+                        title: "Uploading client certificates",
+                        enabled: () => !!context.storedValueCertInputs?.length,
+                        task: (ctx, task) => this.uploadClientCertificates(ctx, testSuiteId, token, task),
+                        exitOnError: false,
+                    },
                     {
                         enabled: () => !flags["file-path"] && !flags["chrome-extension"],
                         task: async (ctx) => {
@@ -564,6 +592,69 @@ class Run extends command_base_1.CommandBase {
         const queryString = queryParams.toString();
         return queryString ? `${apiEndpoint}?${queryString}` : apiEndpoint;
     }
+    async uploadVariableFiles(ctx, testSuiteId, token) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), utils_1.UPLOAD_TIMEOUT_MS);
+        try {
+            ctx.configuration.storedValues = ctx.configuration.storedValues || {};
+            const uploads = await Promise.all(ctx.storedValueFileInputs.map(async (input) => ({
+                name: input.name,
+                url: await (0, variable_file_uploader_1.uploadVariableFile)(this.TESTRIGOR_API2_URL, testSuiteId, token, input.file),
+            })));
+            for (const { name, url } of uploads) {
+                ctx.configuration.storedValues[name] = url;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new Error("Variable files upload timed out. Please check your network connection.");
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    async uploadClientCertificates(ctx, testSuiteId, token, task) {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), utils_1.UPLOAD_TIMEOUT_MS);
+        try {
+            ctx.configuration.clientCertificateOverrides =
+                ctx.configuration.clientCertificateOverrides || {};
+            const uploads = await Promise.all(ctx.storedValueCertInputs.map(async (input) => {
+                const uploaded = await (0, certificate_uploader_1.uploadClientCertificate)(this.TESTRIGOR_API2_URL, testSuiteId, token, input.file, input.password);
+                return {
+                    name: input.name,
+                    certificateId: uploaded.certificateId,
+                    info: uploaded.info,
+                };
+            }));
+            for (const { name, certificateId } of uploads) {
+                ctx.configuration.clientCertificateOverrides[name] = certificateId;
+            }
+            const summary = uploads
+                .map(({ name, info }) => {
+                const subject = info?.subject?.commonName || info?.subject?.distinguishedName;
+                const notAfter = info?.notAfter
+                    ? ` (expires ${info.notAfter.slice(0, 10)})`
+                    : "";
+                return subject ? `${name}: ${subject}${notAfter}` : name;
+            })
+                .join("; ");
+            if (summary) {
+                task.title = `Uploaded client certificate(s): ${summary}`;
+            }
+        }
+        catch (error) {
+            if (error.name === "AbortError") {
+                throw new Error("Client certificates upload timed out. Please check your network connection.");
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
     async callRetest(testSuiteId, configuration, token) {
         return (0, node_fetch_commonjs_1.default)(`${this.TESTRIGOR_API_URL}/apps/${testSuiteId}/retest`, {
             method: "POST",

package/dist/types.d.ts

@@ -65,3 +65,54 @@ export type ChromeExtensionOverrideItem = {
 export type ChromeExtensionOverridesRequest = {
     chromeExtensions: ChromeExtensionOverrideItem[];
 };
+export type StoredValueFileInput = {
+    name: string;
+    file: string;
+};
+export type StoredValueCertInput = {
+    name: string;
+    file: string;
+    password: string;
+};
+export type ParsedVariables = {
+    textValues: Record<string, string>;
+    fileInputs: StoredValueFileInput[];
+    certInputs: StoredValueCertInput[];
+};
+export type ClientCertificateDistinguishedName = {
+    distinguishedName?: string;
+    commonName?: string;
+};
+export type ClientCertificateInfo = {
+    serialNumber?: string;
+    notBefore?: string;
+    notAfter?: string;
+    issuer?: ClientCertificateDistinguishedName;
+    subject?: ClientCertificateDistinguishedName;
+};
+export type CertificateUploadDataApi2Response = {
+    certificateId: string;
+    info?: ClientCertificateInfo;
+};
+export type UploadedClientCertificate = {
+    certificateId: string;
+    info?: ClientCertificateInfo;
+};
+export type CertificateUploadApi2Response = Api2Wrapper & {
+    data: CertificateUploadDataApi2Response;
+};
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+export type FileVariableObject = {
+    type: "FILE";
+    value: string;
+};
+export type CertVariableObject = {
+    type: "CLIENT_CERTIFICATE";
+    value: string;
+    password: string;
+};

package/dist/util/certificate-uploader.d.ts

@@ -0,0 +1,2 @@
+import { UploadedClientCertificate } from "../types";
+export declare function uploadClientCertificate(api2BaseUrl: string, testSuiteId: string, token: string, localFilePath: string, password: string): Promise<UploadedClientCertificate>;

package/dist/util/certificate-uploader.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadClientCertificate = void 0;
+const fs = require("fs");
+const path = require("path");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const type_guards_1 = require("./type-guards");
+async function uploadClientCertificate(api2BaseUrl, testSuiteId, token, localFilePath, password) {
+    const fileName = path.basename(localFilePath);
+    const certBase64 = fs.readFileSync(localFilePath).toString("base64");
+    const response = await (0, node_fetch_commonjs_1.default)(`${api2BaseUrl}/apps/${testSuiteId}/test_data/global_variables/client_certificate`, {
+        method: "POST",
+        body: JSON.stringify({ fileName, certBase64, password }),
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "auth-token": token,
+        },
+    });
+    const responseJson = await response.json();
+    if (!(0, type_guards_1.isCertificateUploadApi2Response)(responseJson)) {
+        throw new Error(`Unexpected response shape from client certificate upload endpoint for '${fileName}'`);
+    }
+    if (!response.ok || responseJson.status !== 200 || !responseJson.data) {
+        throw new Error(`Failed to upload client certificate '${fileName}': ${responseJson.message}`);
+    }
+    return {
+        certificateId: responseJson.data.certificateId,
+        info: responseJson.data.info,
+    };
+}
+exports.uploadClientCertificate = uploadClientCertificate;

package/dist/util/type-guards.d.ts

@@ -0,0 +1,4 @@
+import { CertificateUploadApi2Response, SignedUrlApi2Response } from "../types";
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isSignedUrlApi2Response(value: unknown): value is SignedUrlApi2Response;
+export declare function isCertificateUploadApi2Response(value: unknown): value is CertificateUploadApi2Response;

package/dist/util/type-guards.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCertificateUploadApi2Response = exports.isSignedUrlApi2Response = exports.isPlainObject = void 0;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+exports.isPlainObject = isPlainObject;
+function isSignedUrlApi2Response(value) {
+    return isPlainObject(value) && "status" in value;
+}
+exports.isSignedUrlApi2Response = isSignedUrlApi2Response;
+function isCertificateUploadApi2Response(value) {
+    return isPlainObject(value) && "status" in value;
+}
+exports.isCertificateUploadApi2Response = isCertificateUploadApi2Response;

package/dist/util/variable-file-uploader.d.ts

@@ -0,0 +1 @@
+export declare function uploadVariableFile(api2BaseUrl: string, testSuiteId: string, token: string, localFilePath: string): Promise<string>;

package/dist/util/variable-file-uploader.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadVariableFile = void 0;
+const Fs = require("@supercharge/fs");
+const path = require("path");
+const node_fetch_commonjs_1 = require("node-fetch-commonjs");
+const utils_1 = require("./utils");
+const type_guards_1 = require("./type-guards");
+async function uploadVariableFile(api2BaseUrl, testSuiteId, token, localFilePath) {
+    const fileName = path.basename(localFilePath);
+    const fileSize = Fs.statSync(localFilePath).size;
+    const presignedResp = await (0, node_fetch_commonjs_1.default)(`${api2BaseUrl}/apps/${testSuiteId}/test_data/global_variables/file/pre_signed_url`, {
+        method: "POST",
+        body: JSON.stringify({ fileName }),
+        headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "auth-token": token,
+        },
+    });
+    const presignedJson = await presignedResp.json();
+    if (!(0, type_guards_1.isSignedUrlApi2Response)(presignedJson)) {
+        throw new Error(`Unexpected response shape from presigned URL endpoint for '${fileName}'`);
+    }
+    if (!presignedResp.ok ||
+        presignedJson.status !== 200 ||
+        !presignedJson.data) {
+        throw new Error(`Failed to request presigned URL for variable file '${fileName}': ${presignedJson.message}`);
+    }
+    const fileStream = Fs.createReadStream(localFilePath);
+    const putResp = await (0, node_fetch_commonjs_1.default)(presignedJson.data.url, {
+        method: "PUT",
+        body: fileStream,
+        headers: {
+            "Content-length": `${fileSize}`,
+        },
+    });
+    if (!putResp.ok) {
+        throw new Error(`Failed to upload variable file '${fileName}' to S3: ${putResp.statusText}`);
+    }
+    return (0, utils_1.extractUrlWithoutQueryParams)(presignedJson.data.url);
+}
+exports.uploadVariableFile = uploadVariableFile;

package/dist/util/variables-path-parser.d.ts

@@ -0,0 +1,2 @@
+import { JsonValue, ParsedVariables } from "../types";
+export declare function parseVariablesJson(parsed: JsonValue): ParsedVariables;

package/dist/util/variables-path-parser.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVariablesJson = void 0;
+const fs = require("fs");
+const path = require("path");
+const type_guards_1 = require("./type-guards");
+const MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024;
+const MAX_COMBINED_SIZE_BYTES = 100 * 1024 * 1024;
+const MAX_SIZE_LABEL = "100 MB";
+const MAX_CERT_FILE_SIZE_BYTES = 20 * 1024; // 20 KB
+const MAX_CERT_PASSWORD_LENGTH = 100;
+const MAX_CERT_FILENAME_LENGTH = 100;
+const ERROR_ROOT_NOT_OBJECT = "--variables-path must contain a JSON object at the top level";
+const ERROR_COMBINED_SIZE_EXCEEDED = `Variable files combined size exceeds the maximum allowed (${MAX_SIZE_LABEL})`;
+function isUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+function isFileVariableObject(value) {
+    return ((0, type_guards_1.isPlainObject)(value) &&
+        value.type === "FILE" &&
+        typeof value.value === "string");
+}
+function isCertVariableObject(value) {
+    return ((0, type_guards_1.isPlainObject)(value) &&
+        value.type === "CLIENT_CERTIFICATE" &&
+        typeof value.value === "string" &&
+        typeof value.password === "string");
+}
+function readLocalFileSize(key, filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Variable "${key}": file not found at path "${filePath}"`);
+    }
+    const size = fs.statSync(filePath).size;
+    if (size > MAX_FILE_SIZE_BYTES) {
+        throw new Error(`Variable "${key}": file size exceeds the maximum allowed (${MAX_SIZE_LABEL})`);
+    }
+    return size;
+}
+function validateLocalCertFile(key, value) {
+    if (isUrl(value)) {
+        throw new Error(`Variable "${key}": CLIENT_CERTIFICATE does not support URL values; provide a local .pfx file path`);
+    }
+    if (!fs.existsSync(value)) {
+        throw new Error(`Variable "${key}": file not found at path "${value}"`);
+    }
+    if (!/\.pfx$/i.test(path.basename(value))) {
+        throw new Error(`Variable "${key}": CLIENT_CERTIFICATE requires a .pfx file`);
+    }
+    if (path.basename(value).length > MAX_CERT_FILENAME_LENGTH) {
+        throw new Error(`Variable "${key}": filename is too long (max ${MAX_CERT_FILENAME_LENGTH} chars)`);
+    }
+    if (fs.statSync(value).size > MAX_CERT_FILE_SIZE_BYTES) {
+        throw new Error(`Variable "${key}": certificate file exceeds the maximum allowed (20 KB)`);
+    }
+}
+function parseVariablesJson(parsed) {
+    if (!(0, type_guards_1.isPlainObject)(parsed)) {
+        throw new Error(ERROR_ROOT_NOT_OBJECT);
+    }
+    const textValues = {};
+    const fileInputs = [];
+    const certInputs = [];
+    let combinedSize = 0;
+    for (const [key, raw] of Object.entries(parsed)) {
+        if (typeof raw === "string") {
+            textValues[key] = raw;
+            continue;
+        }
+        if (!(0, type_guards_1.isPlainObject)(raw)) {
+            throw new Error(`Variable "${key}": expected a string or { type: "FILE", value: "..." }`);
+        }
+        if (raw.type === "FILE" && raw.password !== undefined) {
+            throw new Error(`Variable "${key}": "password" field is only valid for CLIENT_CERTIFICATE. Did you mean type:"CLIENT_CERTIFICATE"?`);
+        }
+        if (raw.type === "FILE") {
+            if (!isFileVariableObject(raw)) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:FILE`);
+            }
+            const value = raw.value.trim();
+            if (value.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:FILE`);
+            }
+            if (isUrl(value)) {
+                textValues[key] = value;
+                continue;
+            }
+            combinedSize += readLocalFileSize(key, value);
+            if (combinedSize > MAX_COMBINED_SIZE_BYTES) {
+                throw new Error(ERROR_COMBINED_SIZE_EXCEEDED);
+            }
+            fileInputs.push({ name: key, file: value });
+            continue;
+        }
+        if (raw.type === "CLIENT_CERTIFICATE") {
+            if (!isCertVariableObject(raw)) {
+                if (typeof raw.value !== "string" || raw.value.trim().length === 0) {
+                    throw new Error(`Variable "${key}": missing or empty "value" for type:CLIENT_CERTIFICATE`);
+                }
+                throw new Error(`Variable "${key}": missing or empty "password" for type:CLIENT_CERTIFICATE`);
+            }
+            const value = raw.value.trim();
+            if (value.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "value" for type:CLIENT_CERTIFICATE`);
+            }
+            if (raw.password.length === 0) {
+                throw new Error(`Variable "${key}": missing or empty "password" for type:CLIENT_CERTIFICATE`);
+            }
+            if (raw.password.length > MAX_CERT_PASSWORD_LENGTH) {
+                throw new Error(`Variable "${key}": "password" exceeds the maximum length of ${MAX_CERT_PASSWORD_LENGTH} characters`);
+            }
+            validateLocalCertFile(key, value);
+            certInputs.push({
+                name: key,
+                file: value,
+                password: raw.password,
+            });
+            continue;
+        }
+        if (typeof raw.type === "string" && raw.type.toUpperCase() === "FILE") {
+            throw new Error(`Variable "${key}": unsupported type "${String(raw.type)}". Only "FILE" (uppercase) and "CLIENT_CERTIFICATE" are supported.`);
+        }
+        throw new Error(`Variable "${key}": unsupported type "${String(raw.type)}". Only "FILE" and "CLIENT_CERTIFICATE" are supported.`);
+    }
+    return { textValues, fileInputs, certInputs };
+}
+exports.parseVariablesJson = parseVariablesJson;

package/oclif.manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.44-beta",
+  "version": "0.0.45-beta",
   "commands": {
     "authenticate": {
       "id": "authenticate",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testrigor/testrigor-cli",
-  "version": "0.0.44-beta",
+  "version": "0.0.45-beta",
   "description": "TestRigor Command Line",
   "author": "Ivo Parun Rua @parunruaivo",
   "bin": {