@globisnv/cypress-core 0.0.2 → 0.0.3

package/dist/config.js

@@ -0,0 +1,115 @@
+import { defineConfig } from 'cypress';
+const browserSettings = (browser, launchOptions) => {
+    console.log('launching browser %s', browser.name);
+    const width = 1920;
+    const height = 1080;
+    console.log('setting the browser window size to %d x %d', width, height);
+    if (browser.name === 'chrome' && browser.isHeadless) {
+        launchOptions.args.push(`--window-size=${width},${height}`);
+        // Force screen to be non-retina and just use our given resolution
+        launchOptions.args.push('--force-device-scale-factor=1');
+    }
+    if (browser.name === 'electron' && browser.isHeadless) {
+        // Might not work on CI for some reason
+        launchOptions.preferences.width = width;
+        launchOptions.preferences.height = height;
+    }
+    if (browser.name === 'firefox' && browser.isHeadless) {
+        launchOptions.args.push(`--width=${width}`);
+        launchOptions.args.push(`--height=${height}`);
+    }
+    if (browser.name === 'chrome' && browser.isHeaded) {
+        launchOptions.args.push(`--window-size=${width},${height}`);
+        launchOptions.args.push('--auto-open-devtools-for-tabs');
+    }
+    return launchOptions;
+};
+export function defineGlobisConfig(overrides = {}) {
+    const wsMetricsBuffer = [];
+    return defineConfig({
+        allowCypressEnv: false,
+        e2e: {
+            videosFolder: 'cypress/videos',
+            screenshotsFolder: 'cypress/screenshots',
+            video: true,
+            viewportWidth: 1920,
+            viewportHeight: 1080,
+            videoCompression: false,
+            responseTimeout: 120000,
+            modifyObstructiveCode: false,
+            experimentalMemoryManagement: true,
+            numTestsKeptInMemory: Number(process.env.numTestsKeptInMemory ?? 0),
+            scrollBehavior: 'center',
+            ...overrides.e2e,
+            setupNodeEvents(on, config) {
+                // Sensitive keys never get exposed to the browser via config.expose.
+                const sensitiveEnvKeys = new Set(['password', 'password2', 'api_key', 'QLIKURLS', 'S3_KEY', 'S3_SECRET']);
+                for (const [key, val] of Object.entries(config.env)) {
+                    if (!sensitiveEnvKeys.has(key))
+                        config.expose[key] = val;
+                }
+                const configProcessScopedVariables = { testFailed: false };
+                on('task', {
+                    log(message) {
+                        console.log(message);
+                        return null;
+                    },
+                    bufferWsMetrics(metrics) {
+                        wsMetricsBuffer.push(...metrics);
+                        return null;
+                    },
+                    async flushWsMetrics(_) {
+                        const toFlush = wsMetricsBuffer.splice(0);
+                        const url = process.env.AMP_REMOTE_WRITE_URL;
+                        // No-op when unset — customer repos simply don't get an AMP_REMOTE_WRITE_URL, so metrics never push.
+                        if (!toFlush.length)
+                            return { flushed: 0, skipped: 'no metrics' };
+                        if (!url)
+                            return { flushed: 0, skipped: 'AMP_REMOTE_WRITE_URL not set' };
+                        try {
+                            const { pushMetrics } = await import('./plugins/prometheusWriter.js');
+                            await pushMetrics(toFlush, url);
+                            return { flushed: toFlush.length };
+                        }
+                        catch (err) {
+                            const message = err instanceof Error ? err.message : String(err);
+                            console.error('[prometheusWriter] flush failed:', err);
+                            return { flushed: 0, error: message };
+                        }
+                    },
+                    set(keySet) {
+                        Object.entries(keySet).forEach(([key, value]) => {
+                            configProcessScopedVariables[key] = value;
+                        });
+                        return null;
+                    },
+                    get(keys) {
+                        const result = {};
+                        keys.forEach((key) => {
+                            result[key] = configProcessScopedVariables[key];
+                        });
+                        return result;
+                    },
+                    ...overrides.extraTasks
+                });
+                on('before:browser:launch', (browser, launchOptions) => {
+                    browser ??= {
+                        name: '',
+                        family: 'chromium',
+                        channel: '',
+                        displayName: '',
+                        version: '',
+                        majorVersion: '',
+                        path: '',
+                        isHeaded: false,
+                        isHeadless: false
+                    };
+                    return browserSettings(browser, launchOptions);
+                });
+                // Consumer's own setupNodeEvents (if any) runs after core wiring, on the same `on`/`config`.
+                overrides.e2e?.setupNodeEvents?.(on, config);
+                return config;
+            }
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { DefineGlobisConfigOptions } from './config.js';
+export { defineGlobisConfig } from './config.js';

package/dist/index.js

@@ -0,0 +1,15 @@
+export { defineGlobisConfig } from './config.js';
+// tsHelper is NOT re-exported here on purpose: its top-level `Cypress.expose(...)`
+// call only works in a browser-context (spec/support) process. cypress.config.ts
+// runs in Node, so `import { defineGlobisConfig } from '@globisnv/cypress-core'`
+// must stay safe to use there — barreling tsHelper in would make the root import
+// crash the moment it's used from a config file. Import tsHelper explicitly via
+// `@globisnv/cypress-core/tsHelper` from spec/support files instead.
+// Blueprints and generic command files are consumed via direct subpath imports
+// (e.g. `@globisnv/cypress-core/blueprints/GLO_equipment`) rather than re-exported
+// here — barreling all 132 blueprints buys nothing a direct import doesn't.
+// Custom tsconfig path aliases pointing into node_modules are deliberately NOT
+// used for this: tsconfig-paths-webpack-plugin (which Cypress's default preprocessor
+// relies on) silently ignores path mappings that resolve inside node_modules, so
+// they typecheck fine but fail to bundle. Real package subpath exports don't have
+// that problem — both tsc and webpack resolve them natively.

package/dist/plugins/prometheusWriter.d.ts

@@ -0,0 +1,15 @@
+export interface WsDomMetric {
+    name: string;
+    value: number;
+    labels: {
+        hostname: string;
+        cypress_action: string;
+        formname: string;
+        beanname: string;
+        methodname: string;
+        dataproviderid: string;
+        [key: string]: string;
+    };
+    timestamp: number;
+}
+export declare function pushMetrics(metrics: WsDomMetric[], remoteWriteUrl: string): Promise<void>;

package/dist/plugins/prometheusWriter.js

@@ -0,0 +1,111 @@
+// Node.js only — runs inside the Cypress task runner, never bundled for the browser.
+import * as http from 'node:http';
+import * as https from 'node:https';
+import { URL } from 'node:url';
+import { Sha256 } from '@aws-crypto/sha256-js';
+import { fromContainerMetadata } from '@aws-sdk/credential-provider-imds';
+import { SignatureV4 } from '@aws-sdk/signature-v4';
+import { compress } from 'snappyjs';
+// ─── Minimal Prometheus remote-write protobuf encoder ─────────────────────────
+// WriteRequest { repeated TimeSeries timeseries = 1 }
+// TimeSeries   { repeated Label labels = 1; repeated Sample samples = 2 }
+// Label        { string name = 1; string value = 2 }
+// Sample       { double value = 1; int64 timestamp = 2 }
+function varint(n) {
+    const bytes = [];
+    let v = Math.floor(n);
+    while (v > 127) {
+        bytes.push((v % 128) | 128);
+        v = Math.floor(v / 128);
+    }
+    bytes.push(v);
+    return Buffer.from(bytes);
+}
+function lenField(fieldNum, data) {
+    return Buffer.concat([Buffer.from([(fieldNum << 3) | 2]), varint(data.length), data]);
+}
+function encodeLabel(name, value) {
+    return Buffer.concat([lenField(1, Buffer.from(name, 'utf8')), lenField(2, Buffer.from(value, 'utf8'))]);
+}
+function encodeSample(value, timestampMs) {
+    const doubleBuf = Buffer.allocUnsafe(8);
+    doubleBuf.writeDoubleLE(value, 0);
+    return Buffer.concat([
+        Buffer.from([0x09]), // Field 1, wire type 1 (64-bit LE double)
+        doubleBuf,
+        Buffer.from([0x10]), // Field 2, wire type 0 (varint int64)
+        varint(timestampMs)
+    ]);
+}
+function encodeTimeSeries(metric) {
+    const pairs = [['__name__', metric.name]];
+    for (const [k, v] of Object.entries(metric.labels)) {
+        if (v)
+            pairs.push([k, v]);
+    }
+    pairs.sort((a, b) => (a[0] < b[0] ? -1 : 1));
+    return Buffer.concat([...pairs.map(([n, v]) => lenField(1, encodeLabel(n, v))), lenField(2, encodeSample(metric.value, metric.timestamp))]);
+}
+function buildWriteRequest(metrics) {
+    return Buffer.concat(metrics.map((m) => lenField(1, encodeTimeSeries(m))));
+}
+// ─── HTTP POST ────────────────────────────────────────────────────────────────
+function doPost(url, body, headers) {
+    return new Promise((resolve, reject) => {
+        const parsed = new URL(url);
+        const isHttps = parsed.protocol === 'https:';
+        const lib = isHttps ? https : http;
+        const defaultPort = isHttps ? 443 : 80;
+        const req = lib.request({
+            method: 'POST',
+            hostname: parsed.hostname,
+            port: parsed.port ? parseInt(parsed.port, 10) : defaultPort,
+            path: parsed.pathname + parsed.search,
+            headers: { ...headers, 'Content-Length': String(body.length) }
+        }, (res) => {
+            let resp = '';
+            res.on('data', (c) => {
+                resp += c;
+            });
+            res.on('end', () => {
+                if (res.statusCode && res.statusCode >= 400) {
+                    reject(new Error(`Remote write HTTP ${res.statusCode}: ${resp}`));
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+        req.on('error', reject);
+        req.write(body);
+        req.end();
+    });
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+export async function pushMetrics(metrics, remoteWriteUrl) {
+    if (!metrics.length || !remoteWriteUrl)
+        return;
+    const body = Buffer.from(compress(buildWriteRequest(metrics)));
+    const headers = {
+        'Content-Type': 'application/x-protobuf',
+        'Content-Encoding': 'snappy',
+        'X-Prometheus-Remote-Write-Version': '0.1.0'
+    };
+    const region = process.env.AMP_REGION;
+    if (region) {
+        const url = new URL(remoteWriteUrl);
+        const signer = new SignatureV4({ credentials: fromContainerMetadata(), region, service: 'aps', sha256: Sha256 });
+        const signed = await signer.sign({
+            method: 'POST',
+            protocol: url.protocol,
+            hostname: url.hostname,
+            path: url.pathname + url.search,
+            headers: { ...headers, host: url.hostname },
+            body
+        });
+        await doPost(remoteWriteUrl, body, signed.headers);
+    }
+    else {
+        await doPost(remoteWriteUrl, body, headers);
+    }
+}

package/dist/register.d.ts

@@ -0,0 +1,8 @@
+import './commands/GLO_commands.js';
+import './commands/GLT_commands.js';
+import './commands/FOB_commands.js';
+import './commands/POR_commands.js';
+import './commands/GLJ_commands.js';
+import './commands/GLS_commands.js';
+import './websocketDetector.js';
+import 'cypress-real-events';

package/dist/register.js

@@ -0,0 +1,23 @@
+// Generic commands + shared infrastructure every consumer needs.
+// Customer-specific command files are NOT imported here — each consumer
+// repo imports its own from its local support/.
+import './commands/GLO_commands.js';
+import './commands/GLT_commands.js';
+import './commands/FOB_commands.js';
+import './commands/POR_commands.js';
+import './commands/GLJ_commands.js';
+import './commands/GLS_commands.js';
+import './websocketDetector.js';
+import 'cypress-real-events';
+/**
+ * Lets GLO_closeDashboard (and similar) skip work after a test has already
+ * failed, so cloud reports don't show a secondary "couldn't close dashboard"
+ * error clouding the real one.
+ */
+beforeEach(() => {
+    cy.task('set', { testFailed: false }, { log: false });
+});
+Cypress.on('fail', (err) => {
+    cy.task('set', { testFailed: true }, { log: false });
+    throw err;
+});

package/dist/tsHelper.d.ts

@@ -0,0 +1,161 @@
+export declare const extraParams: {
+    [key: string]: string | undefined;
+};
+export declare const cypressWebsocketDebug: boolean;
+export declare const cypressWebsocketLoader: boolean;
+export declare const input: addDateType;
+export declare const select: addDateType;
+export declare const top: topBottomType;
+export declare const bottom: topBottomType;
+export declare const equal: checkOperatorType;
+export declare const notEqual: checkOperatorType;
+export declare const contains: checkOperatorType;
+export declare const greaterEqual: checkOperatorType;
+export declare const span: clickRowType;
+export declare const row: clickRowType;
+export declare const gridInput: gridInputType;
+export declare const gridInputWithoutEnter: gridInputType;
+export declare const gridDropDown: gridInputType;
+export declare const gridSelect: gridInputType;
+export declare const cypressRecords: deleteRecordsType;
+export declare const leapworkRecords: deleteRecordsType;
+export declare const add = "add";
+export declare const edit = "edit";
+export declare const duplicate = "duplicate";
+export declare const warning = "Warning";
+export declare const error = "Error";
+export declare const info = "Info";
+export declare const partial = "partial";
+export declare const exact = "exact";
+export declare const servoyApi = "/servoy-service/api_v2/";
+export declare const svyNavSelection = "ng$svy_nav_selection";
+export declare const defaultTimeout: number;
+declare const boolAlias: unique symbol;
+export declare const open: true & {
+    [boolAlias]: 'open';
+};
+export declare const close: false & {
+    [boolAlias]: 'close';
+};
+export declare const check: 'true';
+export declare const unCheck: 'false';
+export declare const scrollIntoView: true & {
+    [boolAlias]: 'scrollIntoView';
+};
+export declare const noExplicitScroll: false & {
+    [boolAlias]: 'noExplicitScroll';
+};
+export declare const disableLoadingIndicator: false & {
+    [boolAlias]: 'disableLoadingIndicator';
+};
+export declare const skipCheck: true & {
+    [boolAlias]: 'skipCheck';
+};
+export declare const noSkipCheck: false & {
+    [boolAlias]: 'noSkipCheck';
+};
+export declare const equalBool: true & {
+    [boolAlias]: 'equalBool';
+};
+export declare const noEqualBool: false & {
+    [boolAlias]: 'noEqualBool';
+};
+export declare const showInCommandLog: true & {
+    [boolAlias]: 'showInCommandLog';
+};
+export declare const hideInCommandLog: false & {
+    [boolAlias]: 'hideInCommandLog';
+};
+export declare const useStoredValue: true & {
+    [boolAlias]: 'useStoredValue';
+};
+export declare const noStoredValue: false & {
+    [boolAlias]: 'noStoredValue';
+};
+export declare const defaultUsername: false & {
+    [boolAlias]: 'defaultUsername';
+};
+export declare const alternateUsername: true & {
+    [boolAlias]: 'alternateUsername';
+};
+export declare const disabled: false & {
+    [boolAlias]: 'disabled';
+};
+export declare const enabled: true & {
+    [boolAlias]: 'enabled';
+};
+export declare const isInvalid: true & {
+    [boolAlias]: 'isInvalid';
+};
+export declare const isValid: false & {
+    [boolAlias]: 'isValid';
+};
+export declare const buttonSearch: true & {
+    [boolAlias]: 'buttonSearch';
+};
+export declare const typeSearch: false & {
+    [boolAlias]: 'typeSearch';
+};
+export type OpenClose = typeof open | typeof close;
+export type CheckState = typeof check | typeof unCheck | undefined;
+export type skipCheckFlag = typeof skipCheck | typeof noSkipCheck;
+export type scrollIntoViewFlag = typeof scrollIntoView | typeof noExplicitScroll;
+export type exactMatchFlag = typeof equalBool | typeof noEqualBool;
+export type showInCommandLogFlag = typeof showInCommandLog | typeof hideInCommandLog;
+export type useStoredValueFlag = typeof useStoredValue | typeof noStoredValue;
+export type usernameFlag = typeof defaultUsername | typeof alternateUsername;
+export type disabledFlag = typeof disabled | typeof enabled;
+export type validityFlag = typeof isInvalid | typeof isValid;
+export type searchTypeFlag = typeof buttonSearch | typeof typeSearch;
+export declare const clearExistingFilters: Flag<'clearExistingFilters'>;
+/**
+ * Generates a date string based on the current date or a future date by adding days.
+ *
+ * @param {number} [daysToAdd] - Number of days to add to the current date. If not provided, returns today's date.
+ * @returns {string} - The date string in 'DD/MM/YYYY' format.
+ * @example
+ * Returns today's date
+ * const today = getDate();
+ *
+ * Returns a date 3 days from now
+ * const futureDate = getDate(3);
+ */
+export declare function getDate(daysToAdd?: number): string;
+export declare function getClearDataFormula(formulaName: string): string;
+export declare function getRandomNumberInRange(startValue: number, endValue: number): number;
+export declare function numberToCommaValues(inputNumber: number): string;
+/**
+ * Generates a UUID (Universally Unique Identifier) using the v4 method.
+ * @param {number} [length] - The desired length of the random string. If not provided, the full UUID is generated.
+ * @returns {string} The generated UUID.
+ */
+export declare function getUUID(length?: number): string;
+/**
+ * Converts a localized number to a standard format for calculations or formulas.
+ * @param {string | number | undefined} value - The input value to be converted.
+ * @returns {number} The converted number
+ * @throws {Error} If the value is undefined or cannot be converted to a valid number. Useful to stop execution of the test if the value is not as expected.
+ */
+export declare function parseLocalizedNumber(value: string | number | undefined): number;
+/**
+ *
+ * Gets the jenkins build number to use as a UUID,
+ * will fall back to a random generated 4-character UUID if not found.
+ * @returns {string} CYP + build number or random 4-character UUID
+ */
+export declare const getOrCreateUuid: (index?: number) => string;
+/**
+ * Returns the ISO 8601 week number for the given date.
+ *
+ * The calculation normalizes the input to UTC (so local time is ignored) and follows the ISO-8601
+ * rule where weeks start on Monday and week 1 is the week containing the year's first Thursday.
+ *
+ * @param d - The Date for which to compute the ISO week number.
+ * @returns The ISO week number (1..53) for the provided date.
+ */
+export declare const getISOWeek: (d: Date) => number;
+export declare const DELETE_CYPRESS_RECORDS = "var _query = 'SELECT Name FROM sysobjects WHERE xtype = ? ';\nvar _ds = globals.svy_db_dataset('globis_development', _query, ['U']);\nvar _check_query, _check_args, _check_ds;\nvar _delete_query , _delete_args, _ok;\n\nfor(var i = 1 ; i <= _ds.getMaxRowIndex() ; i++)\n{\n    _check_query = 'SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE  TABLE_NAME = ? AND COLUMN_NAME = ?'\n    _check_args = [_ds.getValue(i,1), 'sys_creationuser']\n    _check_ds = globals.svy_db_dataset('globis_development', _check_query, _check_args);\n    if(_check_ds.getMaxRowIndex() > 0)\n    {\n        _delete_query = 'DELETE FROM ' + _ds.getValue(i,1) +  ' WHERE lower(sys_creationuser) = \\'cypress\\' ' \n        _delete_args = []\n        _ok = globals.svy_db_sql('globis_development', 'environment', _delete_query, _delete_args);   \n    }\n}\n\nvar _result = scopes.globals.openCurrentPeriod();\n\n$R{true}";
+export declare const DELETE_LEAPWORK_RECORDS = "var _query = 'SELECT Name FROM sysobjects WHERE xtype = ? ';\nvar _ds = globals.svy_db_dataset('globis_development', _query, ['U']);\nvar _check_query, _check_args, _check_ds;\nvar _delete_query , _delete_args, _ok;\n\nfor(var i = 1 ; i <= _ds.getMaxRowIndex() ; i++)\n{\n    _check_query = 'SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE  TABLE_NAME = ? AND COLUMN_NAME = ?'\n    _check_args = [_ds.getValue(i,1), 'sys_creationuser']\n    _check_ds = globals.svy_db_dataset('globis_development', _check_query, _check_args);\n    if(_check_ds.getMaxRowIndex() > 0)\n    {\n        _delete_query = 'DELETE FROM ' + _ds.getValue(i,1) +  ' WHERE lower(sys_creationuser) = \\'leapwork\\' ' \n        _delete_args = []\n        _ok = globals.svy_db_sql('globis_development', 'environment', _delete_query, _delete_args);   \n    }\n}\n\nvar _result = scopes.globals.openCurrentPeriod();\n\n$R{true}";
+export declare const S3_PLUGIN_TEST: (key: string, secret: string) => string;
+export declare const LOG_PLUGIN_TEST: string;
+export {};