@syngrisi/syngrisi 2.2.1

package/src/server/data/get_devices.sh

@@ -0,0 +1,2 @@
+curl -u "$BROWSERSTACK_USER:$BROWSERSTACK_PASSWORD" \
+-X GET "https://api-cloud.browserstack.com/app-automate/devices.json" > devices.json

package/src/server/lib/AppSettings.js

@@ -0,0 +1,56 @@
+/* eslint-disable dot-notation */
+class AppSettings {
+    constructor() {
+        this.model = require('../models').AppSettings;
+        (async () => {
+            this.cache = await this.model.find()
+                .lean()
+                .exec();
+        })();
+    }
+
+    count() {
+        return this.model.countDocuments().exec();
+    }
+
+    async loadInitialFromFile() {
+        const settings = require('./initialAppSettings.json');
+        // console.log({ settings });
+        await this.model.insertMany(settings);
+        this.cache = settings;
+    }
+
+    async get(name) {
+        return this.cache?.find((x) => x.name === name)
+            || (this.model.findOne({ name })
+                .exec());
+    }
+
+    async set(name, value) {
+        const item = await this.model.findOneAndUpdate({ name }, { value });
+        await item.save();
+        this.cache.find((x) => x.name === name)['value'] = value;
+    }
+
+    async enable(name) {
+        const item = await this.model.findOneAndUpdate({ name }, { enabled: true });
+        await item.save();
+        this.cache.find((x) => x.name === name)['enabled'] = true;
+    }
+
+    async disable(name) {
+        const item = await this.model.findOneAndUpdate({ name }, { enabled: false });
+        await item.save();
+        this.cache.find((x) => x.name === name)['enabled'] = false;
+    }
+
+    async isAuthEnabled() {
+        return process.env.SYNGRISI_AUTH === '1' || (await this.get('authentication'))?.value === 'true';
+    }
+
+    async isFirstRun() {
+        return (await this.get('first_run'))?.value === 'true';
+    }
+}
+
+exports.AppSettings = AppSettings;

package/src/server/lib/admin.json

@@ -0,0 +1,9 @@
+{
+  "username": "Administrator",
+  "role": "admin",
+  "firstName": "Syngrisi",
+  "lastName": "Admin",
+  "salt": "861d0193d9a4cd27597d672dd73100b1218cc7629c59bf18f9faef4480d1f58a",
+  "password": "cdd8541c318008fe0eee35d311b428c666d7ddf78722735e40b21b0b9e734eabe1b60f6db6deb8f3f101ed559a7365a497bfa73156ba3fadcbb14c5cae441edfe301568a47320abcda308920fecc482b1082468fd2197893561f5d174ecafdfb930bdc8e070fbed07353231d255616d3072e899a4ae1e6ff71f171edc34ba871d091b657a3207b571d2db0f3fce1fb2bc48942657d35aac7fa1fc2ebcbacdc00e46b184e1e5e4988171bcd843f7bb4adb2920df06c4f6b830154234350f9d65cc6e10d445a242c2149a3ce24458bd741035629bb73bdf29e0db4dcd3e37d85332d58d58674ca56b632294135a3354705b3281ea7564b962d544cfcee7069f3065c394098e11999385b077755f9c7e3d42f55b23ecb3366187d3a8ce2475615fbd06d707020274d7f50fe6c824e589955a667210fa031828f832e3cc050d1c0c5360647bfd88d411d3f76e8c6d9c610e2bc5a22da498888d2c94ad25b6448ca2eb9606210b2018136116fda6fdd87b24bcdfe86daefcdaa97d1f9e3a102188a4314a5a4018599cc70dab82157f5d88f7ada008a1f8e0d6e8abf51ed87ebdab982c01645f4f907414d1bb13b1fac410648cc2e94554ecbe0f472aee26623888878139bd44e109d5ce673ecfbe71269d22bea55a03ad4409fc8578de6001f5601fab4cf800be1d420f76586ed9c31214f30c632de99260256c9d2ce45476c135d32",
+  "apikey": "c6e10d445a242c2149a3ce24458bd741035629bb73bdf29e0db4dcd3e37d85332d58d58674ca56b632294135a3354705b3281ea7564b962d544cfcee7069f3065c394098e11999385b077755f9c7e3d42f55b23ecb336618"
+}

package/src/server/lib/comparator.js

@@ -0,0 +1,147 @@
+const $this = this;
+$this.logMeta = {
+    scope: 'comparator',
+    msgType: 'COMPARE',
+};
+
+// const {
+//     rect,
+//     PngImage,
+// } = require('node-libpng');
+
+const compareImages = require('./compareImagesNode');
+
+// if (process.env['COMPARE_METHOD'] === '2') {
+//     compareImages = require('resemblejs/compareImages');
+// } else {
+//     compareImages = require('./compareImagesNode');
+// }
+
+const DEFAULT_OPTIONS = {
+    output: {
+        // errorType: 'movement', //flat | movement | flatDifferenceIntensity | movementDifferenceIntensity | diffOnly):
+        largeImageThreshold: 0,
+        outputDiff: true,
+        errorType: 'flat',
+        transparency: 0,
+    },
+    // scaleToSameSize: true,
+    // isSameDimensions: false,
+    // useOriginalSize: true,
+    ignore: 'nothing', // nothing,less, antialiasing, colors, alpha
+};
+
+async function makeDiff(imgData1, imgData2, options = {}) {
+    const opts = Object.assign(DEFAULT_OPTIONS, options);
+    // The parameters can be Node Buffers
+    // data is the same as usual with an additional getBuffer() function
+    opts.ignoreRectangles = options.ignoredBoxes;
+    // noinspection UnnecessaryLocalVariableJS
+    const compareData = await compareImages(
+        imgData1,
+        imgData2,
+        opts
+    );
+    return compareData;
+}
+
+// async function compareWithVerticalShiftingStabilization(baselineOrigin, actualOrigin, method, opts) {
+//     const logOpts = {
+//         scope: 'compareWithVerticalShiftingStabilization',
+//         itemType: 'image',
+//         msgType: 'GET_DIFF',
+//     };
+//     try {
+//         const image1 = new PngImage(baselineOrigin);
+//         const image2 = new PngImage(actualOrigin);
+//         const diff = [];
+//         const vShifting = parseInt(opts.vShifting, 10);
+//         for (let i = 1; i <= vShifting; i += 1) {
+//             if (method === 'downup') {
+//                 image1.crop(rect(0, 0, image1.width, (image1.height - i)));
+//                 image2.crop(rect(0, i, image2.width, (image2.height - i)));
+//             }
+//             if (method === 'updown') {
+//                 image1.crop(rect(0, i, image1.width, (image1.height - i)));
+//                 image2.crop(rect(0, 0, image2.width, (image2.height - i)));
+//             }
+//
+//             // eslint-disable-next-line no-await-in-loop
+//             const result = await makeDiff(image1.encode(), image2.encode(), opts);
+//
+//             result.stabMethod = method;
+//             result.vOffset = i;
+//             result.topStablePixels = vShifting;
+//             diff.push(result);
+//         }
+//         return diff;
+//     } catch (e) {
+//         const errMsg = `error in compareWithVerticalShiftingStabilization ${e}\n ${e?.stack || e.toString()}`;
+//         log.error(errMsg, $this, logOpts);
+//         throw new Error(errMsg);
+//     }
+// }
+
+async function getDiff(baselineOrigin, actualOrigin, opts = {}) {
+    const logOpts = {
+        scope: 'getDiff',
+        itemType: 'image',
+        msgType: 'GET_DIFF',
+    };
+    try {
+        const executionTimer = process.hrtime();
+        // direct comparison
+        log.debug(`SAMPLE #1: ${process.hrtime(executionTimer)
+            .toString()}`, $this, logOpts);
+
+        const directDiff = await makeDiff(baselineOrigin, actualOrigin, opts);
+        log.debug(`SAMPLE #2: ${process.hrtime(executionTimer)
+            .toString()}`, $this, logOpts);
+
+        directDiff.executionTotalTime = process.hrtime(executionTimer)
+            .toString();
+
+        log.debug(`SAMPLE #3: ${process.hrtime(executionTimer)
+            .toString()}`, $this, logOpts);
+        log.debug(`the diff is: ${JSON.stringify(directDiff, null, 4)}`, $this, logOpts);
+
+        return directDiff;
+
+        // if (directDiff.rawMisMatchPercentage.toString() === '0'
+        //     || !opts.vShifting
+        //     || (opts.vShifting && parseInt(opts.vShifting, 10) < 1)) {
+        //     return directDiff;
+        // }
+        //
+        // // compare/analyse with vertical shifting
+        // let diffs = [directDiff];
+        // /**
+        //  * up/down shifting:
+        //  *   e.g.: baseline (right) image has top-margin: 0 and actual(wrong) - 1
+        //  * down/up shifting
+        //  *   e.g.: baseline (right) image has top-margin: 1 and actual(wrong) - 2
+        //  */
+        // diffs = [...diffs,
+        //     ...(await compareWithVerticalShiftingStabilization(baselineOrigin, actualOrigin, 'updown', opts))];
+        // diffs = [...diffs,
+        //     ...(await compareWithVerticalShiftingStabilization(baselineOrigin, actualOrigin, 'downup', opts))];
+        // log.debug(`SAMPLE #4 (vShifting): ${process.hrtime(executionTimer)
+        //     .toString()}`, $this, logOpts);
+        // const values = await Promise.all(diffs);
+        // console.table(values, ['stabMethod', 'vOffset', 'topStablePixels', 'rawMisMatchPercentage', 'analysisTime']);
+        //
+        // // search result with lowest misMatchPercentage
+        // const moreFittingResult = values.reduce(
+        //     (prev, current) => ((prev.misMatchPercentage < current.misMatchPercentage) ? prev : current)
+        // );
+        // moreFittingResult.executionTotalTime = process.hrtime(executionTimer)
+        //     .toString();
+        // log.silly(`${JSON.stringify(moreFittingResult, null, '  ')}`, $this, logOpts);
+        // return moreFittingResult;
+    } catch (e) {
+        log.error(e.stack || e.toString(), $this, logOpts);
+        throw new Error(e);
+    }
+}
+
+exports.getDiff = getDiff;

package/src/server/lib/compareImagesNode.js

@@ -0,0 +1,60 @@
+const resemble = require('@syngrisi/node-resemble.js');
+
+async function streamToBuffer(stream) {
+    return new Promise((resolve, reject) => {
+        const data = [];
+
+        stream.on('data', (chunk) => {
+            data.push(chunk);
+        });
+
+        stream.on('end', () => {
+            resolve(Buffer.concat(data));
+        });
+
+        stream.on('error', (err) => {
+            reject(err);
+        });
+    });
+}
+
+module.exports = function compareImages(image1, image2, options) {
+    return new Promise(
+        (resolve, reject) => {
+            try {
+                const ignoreTransform = {
+                    antialiasing: 'ignoreAntialiasing',
+                    colors: 'ignoreColors',
+                    nothing: 'ignoreNothing',
+                };
+                const ignoreMethod = ignoreTransform[options.ignore] ? ignoreTransform[options.ignore] : 'ignoreAntialiasing';
+                const outputOpts = options.output;
+                resemble.outputSettings(
+                    outputOpts
+                );
+                let ignoredRect;
+                if (options.ignoreRectangles) {
+                    ignoredRect = options.ignoreRectangles.map((it) => {
+                        delete it.name;
+                        return [it.left, it.top, it.right - it.left, it.bottom - it.top];
+                    });
+                }
+
+                resemble(image1)
+                    .compareTo(image2)[ignoreMethod]()
+                    .ignoreRectangles(ignoredRect)
+                    .onComplete(async (data) => {
+                        console.log(data);
+                        const stream = await data.getDiffImage();
+                        const buffer = await streamToBuffer(stream.pack());
+                        data.getBuffer = function () {
+                            return buffer;
+                        };
+                        return resolve(data);
+                    });
+            } catch (e) {
+                return reject(e);
+            }
+        }
+    );
+};

package/src/server/lib/dbItems.js

@@ -0,0 +1,215 @@
+/* eslint-disable no-underscore-dangle,func-names */
+/* global log */
+const mongoose = require('mongoose');
+
+const {
+    Suite,
+    Run,
+    App
+} = require('../models');
+
+const $this = this;
+$this.logMeta = {
+    scope: 'dbitems',
+    msgType: 'DB',
+};
+
+// COMMON
+async function updateItem(itemType, filter, params) {
+    const logOpts = {
+        scope: 'updateItem',
+        msgType: 'UPDATE',
+        itemType,
+    };
+    log.debug(`update item type: '${itemType}', filter: '${JSON.stringify(filter)}', params: '${JSON.stringify(params)}'`, $this, logOpts);
+    const itemModel = await mongoose.model(itemType)
+        .findOne(filter);
+    const updatedItem = await itemModel.updateOne(params);
+    log.debug(`'${itemType}' was updated: '${JSON.stringify(updatedItem)}'`, $this, { ...logOpts, ...{ ref: itemModel._id } });
+    return updatedItem;
+}
+
+exports.updateItem = updateItem;
+
+async function updateItemDate(mdClass, id) {
+    log.debug(`update date for the item: '${mdClass}' with id: '${id}'`, $this);
+    const itemModel = await mongoose.model(mdClass)
+        .findById(id);
+    const updatedItem = await itemModel.updateOne({ updatedDate: Date.now() });
+    log.debug(`'${mdClass}' date updated: '${JSON.stringify(itemModel)}'`, $this);
+    return updatedItem;
+}
+
+exports.updateItemDate = updateItemDate;
+
+const createItemIfNotExist = async function (modelName, params, logsMeta = {}) {
+    const logOpts = {
+        scope: 'createItemIfNotExist',
+        msgType: 'CREATE',
+        itemType: modelName,
+    };
+    try {
+        const itemModel = mongoose.model(modelName);
+        const options = {
+            upsert: true,
+            new: true,
+            setDefaultsOnInsert: true
+        };
+
+        await itemModel.init();
+        const item = await itemModel
+            .findOneAndUpdate(
+                params,
+                params,
+                options
+            );
+
+        log.info(`ORM item '${modelName}' was created: '${JSON.stringify(item)}'`, $this, { ...logOpts, ...{ ref: item._id }, ...logsMeta });
+        return item;
+    } catch (e) {
+        log.debug(`cannot create '${modelName}' ORM item, error: '${e.stack || e}'`, $this, { ...logOpts, ...logsMeta });
+    }
+    return null;
+};
+
+exports.createItemIfNotExistAsync = createItemIfNotExist;
+exports.createItemIfNotExist = createItemIfNotExist;
+
+async function createItemProm(modelName, params) {
+    try {
+        const itemModel = mongoose.model(modelName);
+        log.debug(`start to create ORM item via promise: '${modelName}', params: '${JSON.stringify(params)}'`, $this);
+        const item = await itemModel.create(params);
+        return item;
+    } catch (e) {
+        const errMsg = `cannot create '${modelName}', error: '${e.stack || e}'`;
+        log.error(errMsg, $this);
+        throw new Error(errMsg);
+    }
+}
+
+// SPECIFIC
+exports.createTest = async function createTest(params) {
+    return createItemProm('VRSTest', params);
+};
+
+exports.createUser = async function createUser(params) {
+    return createItemProm('VRSUser', params)
+        .catch((e) => Promise.reject(e));
+};
+
+exports.createAppIfNotExist = async function createAppIfNotExist(params) {
+    const logOpts = {
+        scope: 'createAppIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSApp',
+    };
+    if (!params.name) return {};
+    // throw new Error(`Cannot create app, wrong params: '${JSON.stringify(params)}'`);
+
+    log.debug(`try to create app if exist, params: '${JSON.stringify(params)}'`,
+        $this, logOpts);
+
+    let app = await App.findOne({ name: params.name })
+        .exec();
+
+    if (app) {
+        log.debug(`app already exist: '${JSON.stringify(params)}'`,
+            $this, logOpts);
+        return app;
+    }
+
+    app = await App.create(params);
+    log.debug(`app with name: '${params.name}' was created`,
+        $this, logOpts);
+    return app;
+};
+
+const createSuiteIfNotExist = async function (params, logsMeta = {}) {
+    const logOpts = {
+        scope: 'createSuiteIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSSuite',
+    };
+    if (!params.name || !params.app) throw new Error(`Cannot create suite, wrong params: '${JSON.stringify(params)}'`);
+
+    log.debug(`try to create suite if exist, params: '${JSON.stringify(params)}'`,
+        $this,
+        { ...logOpts, ...logsMeta });
+
+    let suite = await Suite.findOne({ name: params.name })
+        .exec();
+
+    if (suite) {
+        log.debug(`suite already exist: '${JSON.stringify(params)}'`,
+            $this,
+            { ...logOpts, ...logsMeta });
+        return suite;
+    }
+
+    suite = await Suite.create(params);
+
+    log.debug(`suite with name: '${params.name}' was created`,
+        $this,
+        { ...logOpts, ...logsMeta });
+    return suite;
+};
+
+exports.createSuiteIfNotExist = createSuiteIfNotExist;
+
+const createRunIfNotExist = async function (params, logsMeta = {}) {
+    const logOpts = {
+        scope: 'createRunIfNotExist',
+        msgType: 'CREATE',
+        itemType: 'VRSRun',
+    };
+    let run;
+    try {
+        if (!params.name || !params.app || !params.ident) {
+            throw new Error(`Cannot create run, wrong params: '${JSON.stringify(params)}'`);
+        }
+
+        log.debug(`try to create run if exist, params: '${JSON.stringify(params)}'`,
+            $this,
+            { ...logOpts, ...logsMeta });
+
+        let run = await Run.findOne({ ident: params.ident })
+            .exec();
+
+        if (run) {
+            log.debug(`run already exist: '${JSON.stringify(params)}'`,
+                $this,
+                { ...logOpts, ...logsMeta });
+            return run;
+        }
+
+        run = await Run.create({
+            ...params,
+            createdDate: params.createdDate || new Date()
+        });
+
+        log.debug(`run with name: '${params.name}' was created: ${run}`,
+            $this,
+            { ...logOpts, ...logsMeta });
+        return run;
+    } catch (e) {
+        // e ==== {"ok":0,"code":11000,"codeName":"DuplicateKey","keyPattern":{"ident":1},"keyValue":{"ident":"cd933acc-6ecb-472c-8dd1-03ec00260bec"}}
+        if (e.code === 11000) {
+            log.warn(`run key duplication collision: '${JSON.stringify(params)}', error: '${e.stack || e}'`,
+                $this,
+                { ...logOpts, ...logsMeta });
+            run = await Run.findOne({
+                name: params.name,
+                ident: params.ident
+            });
+            log.warn(`run key duplication collision, found: '${JSON.stringify(run)}'`, $this, { ...logOpts, ...logsMeta });
+            if (run) return run;
+        }
+        log.error(`cannot create run, params: '${JSON.stringify(params)}', error: '${e.stack || e}', obj: ${JSON.stringify(e)}`,
+            $this,
+            { ...logOpts, ...logsMeta });
+        throw e;
+    }
+};
+
+exports.createRunIfNotExist = createRunIfNotExist;