@syngrisi/syngrisi 2.2.2 → 2.2.6-alpha.0

package/src/server/data/custom_devices.json

@@ -1,8 +0,0 @@
-[
-    {
-        "os": "Windows",
-        "os_version": "15",
-        "device": "iPhone XS",
-        "realMobile": true
-    }
-]

package/src/server/lib/AppSettings.js

@@ -1,56 +0,0 @@
-/* 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/comparator.js

@@ -1,147 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,215 +0,0 @@
-/* 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;

package/src/server/lib/ensureLogin/ensureLoggedOut.js

@@ -1,44 +0,0 @@
-/**
- * Ensure that no user is logged in before proceeding to next route middleware.
- *
- * This middleware ensures that no user is logged in.  If a request is received
- * that is authenticated, the request will be redirected to another page (by
- * default to `/`).
- *
- * Options:
- *   - `redirectTo`   URL to redirect to in logged in, defaults to _/_
- *
- * Examples:
- *
- *     app.get('/login',
- *       ensureLoggedOut(),
- *       function(req, res) { ... });
- *
- *     app.get('/login',
- *       ensureLoggedOut('/home'),
- *       function(req, res) { ... });
- *
- *     app.get('/login',
- *       ensureLoggedOut({ redirectTo: '/home' }),
- *       function(req, res) { ... });
- *
- * @param {Object} options
- * @return {Function}
- * @api public
- */
-module.exports = function ensureLoggedOut(options) {
-    let opts;
-    if (typeof options === 'string') {
-        opts = { redirectTo: options };
-    }
-    opts = options || {};
-
-    const url = opts.redirectTo || '/';
-
-    return function (req, res, next) {
-        if (req.isAuthenticated && req.isAuthenticated()) {
-            return res.redirect(url);
-        }
-        return next();
-    };
-};

package/src/server/lib/getElementsByPixPositionsFromDump.js

@@ -1,72 +0,0 @@
-const getElementsByPositionFromDump = function getElementsByPositionFromDump(x, y, dump, offset = 1) {
-    return new Promise(function (resolve, reject) {
-        try {
-            // check if position is gets into dumped elements rects boundaries
-            let data = dump
-                .filter(function (item) {
-                    return (x >= item.left) &&
-                        (x <= item.right) &&
-                        (y >= item.top) &&
-                        (y <= item.bottom);
-                })
-                .sort((a, b) => (a.domPath.length) < (b.domPath.length) ? 1 : -1);
-            if (data.length < 1) {
-                return resolve(null);
-            }
-            const pos = data[0];
-            return resolve({
-                tag: pos.tag,
-                id: pos.id,
-                x: pos.x,
-                y: pos.y,
-                width: pos.width,
-                height: pos.height,
-                domPath: pos.domPath,
-                request: `${x}, ${y}`
-            });
-        } catch (e) {
-            return reject(e);
-        }
-    });
-};
-const getAllElementsByPositionFromDump = function getAllElementsByPositionFromDump(dump, positions) {
-    return new Promise(function (resolve, reject) {
-        try {
-            let executionTimer = process.hrtime();
-            console.log(`Start parse elements from dump based on diff`);
-            let promResults = [];
-            for (const position of positions) {
-                const el = getElementsByPositionFromDump(position.x, position.y, dump);
-                promResults.push(el);
-
-            }
-            console.log(`Promises formed, time: ${process.hrtime(executionTimer)
-                .toString()}`);
-
-            let dumpResults = {};
-            Promise.all(promResults)
-                .then((values) => {
-                    console.log(`Promises resolved, time: ${process.hrtime(executionTimer)
-                        .toString()}`);
-                    for (el of values) {
-                        // to make dump unique
-                        if (el !== null) {
-                            const key = `${el.tag}_${el.id}_${el.x}_${el.y}_${el.width}_${el.height}_${el.domPath.toString()}`;
-                            dumpResults[key] = el;
-                        }
-                    }
-                    console.log(`End parse elements from dump based on diff, time: '${process.hrtime(executionTimer)
-                        .toString()}'`);
-                    return resolve(Object.values(dumpResults)
-                        .map(x => x));
-                });
-        } catch (e) {
-            reject(e);
-        }
-    });
-};
-
-module.exports = {
-    getElementsByPositionFromDump: getElementsByPositionFromDump,
-    getAllElementsByPositionFromDump: getAllElementsByPositionFromDump,
-};