Merge pull request #467 from gemini-testing/HERMIONE-781.undo

feat: undo screen accept

Author: KuznetsovRoman

lib/common-utils.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const crypto = require('crypto');
 const {pick} = require('lodash');
 const url = require('url');
 const axios = require('axios');
@@ -15,6 +16,10 @@ const {
     QUEUED
 } = require('./constants/test-statuses');
 
+exports.getShortMD5 = (str) => {
+    return crypto.createHash('md5').update(str, 'ascii').digest('hex').substr(0, 7);
+};
+
 const statusPriority = [
     // non-final
     RUNNING, QUEUED,

lib/gui/app.js

@@ -55,6 +55,10 @@ module.exports = class App {
         return this._toolRunner.updateReferenceImage(failedTests);
     }
 
+    undoAcceptImages(imageIds) {
+        return this._toolRunner.undoAcceptImages(imageIds);
+    }
+
     async findEqualDiffs(data) {
         return this._toolRunner.findEqualDiffs(data);
     }

lib/gui/server.js

@@ -89,6 +89,12 @@ exports.start = async ({paths, hermione, guiApi, configs}) => {
             .catch(({message}) => res.status(INTERNAL_SERVER_ERROR).send({error: message}));
     });
 
+    server.post('/undo-accept-images', (req, res) => {
+        app.undoAcceptImages(req.body)
+            .then((updated) => res.json(updated))
+            .catch(({message}) => res.status(INTERNAL_SERVER_ERROR).send({error: message}));
+    });
+
     server.post('/get-find-equal-diffs-data', (req, res) => {
         try {
             const data = app.getImageDataToFindEqualDiffs(req.body);

lib/gui/tool-runner/index.js

@@ -15,7 +15,8 @@ const {logger} = require('../../common-utils');
 const reporterHelper = require('../../reporter-helpers');
 const {UPDATED} = require('../../constants/test-statuses');
 const {DATABASE_URLS_JSON_NAME, LOCAL_DATABASE_NAME} = require('../../constants/database');
-const {formatId, getShortMD5, mkFullTitle, mergeDatabasesForReuse, filterByEqualDiffSizes} = require('./utils');
+const {getShortMD5} = require('../../common-utils');
+const {formatId, mkFullTitle, mergeDatabasesForReuse, filterByEqualDiffSizes} = require('./utils');
 const {getTestsTreeFromDatabase} = require('../../db-utils/server');
 
 module.exports = class ToolRunner {
@@ -120,6 +121,19 @@ module.exports = class ToolRunner {
         });
     }
 
+    async undoAcceptImages(imageIds) {
+        const {
+            referencesToRemove,
+            referencesToUpdate,
+            ...rest
+        } = await this._reportBuilder.undoAcceptImages(imageIds, this._reportPath);
+
+        await reporterHelper.overwriteReferenceImage(referencesToUpdate, this._reportPath);
+        await reporterHelper.removeReferenceImage(referencesToRemove);
+
+        return rest;
+    }
+
     async findEqualDiffs(images) {
         const [selectedImage, ...comparedImages] = images;
         const {tolerance, antialiasingTolerance} = this.config;

lib/gui/tool-runner/utils.js

@@ -4,7 +4,6 @@ const _ = require('lodash');
 const path = require('path');
 const fs = require('fs-extra');
 const chalk = require('chalk');
-const crypto = require('crypto');
 const Database = require('better-sqlite3');
 
 const {logger} = require('../../common-utils');
@@ -13,10 +12,6 @@ const {mergeTables} = require('../../db-utils/server');
 
 exports.formatId = (hash, browserId) => `${hash}/${browserId}`;
 
-exports.getShortMD5 = (str) => {
-    return crypto.createHash('md5').update(str, 'ascii').digest('hex').substr(0, 7);
-};
-
 exports.mkFullTitle = ({suite, state}) => {
     return suite.path.length > 0
         ? `${suite.path.join(' ')} ${state.name}`

lib/report-builder/gui.js

@@ -1,12 +1,15 @@
 'use strict';
 
 const _ = require('lodash');
+const path = require('path');
+
 const StaticReportBuilder = require('./static');
 const GuiTestsTreeBuilder = require('../tests-tree-builder/gui');
 const {IDLE, RUNNING, SKIPPED, FAIL, SUCCESS, UPDATED} = require('../constants/test-statuses');
 const {hasResultFails, hasNoRefImageErrors} = require('../static/modules/utils');
-const {isSkippedStatus} = require('../common-utils');
-const {getConfigForStaticFile} = require('../server-utils');
+const {isSkippedStatus, isUpdatedStatus} = require('../common-utils');
+const {getConfigForStaticFile, deleteFile} = require('../server-utils');
+const {DB_COLUMNS} = require('../constants/database');
 
 module.exports = class GuiReportBuilder extends StaticReportBuilder {
     static create(...args) {
@@ -103,6 +106,78 @@ module.exports = class GuiReportBuilder extends StaticReportBuilder {
         return isUpdated ? attempt : attempt + 1;
     }
 
+    async undoAcceptImages(imageIds, reportPath) {
+        const updatedImages = [], removedResults = [], referencesToRemove = [], referencesToUpdate = [];
+
+        for (const imageId of imageIds) {
+            const {
+                updatedImage,
+                removedResult,
+                referenceToRemove,
+                referenceToUpdate
+            } = await this._undoAcceptImage(imageId, reportPath);
+
+            updatedImage && updatedImages.push(updatedImage);
+            removedResult && removedResults.push(removedResult);
+            referenceToRemove && referencesToRemove.push(referenceToRemove);
+            referenceToUpdate && referencesToUpdate.push(referenceToUpdate);
+        }
+
+        return {updatedImages, removedResults, referencesToRemove, referencesToUpdate};
+    }
+
+    async _undoAcceptImage(imageId, reportPath) {
+        const {
+            suitePath,
+            browserName,
+            stateName,
+            status,
+            timestamp,
+            image,
+            previousImage,
+            resultIdToRemove
+        } = this._testsTree.getResultDataToUnacceptImage(imageId);
+
+        if (!isUpdatedStatus(status)) {
+            return {};
+        }
+
+        const fullTitle = suitePath.join(' ');
+        const previousExpectedImgPath = _.get(previousImage, 'expectedImg.path', null);
+        const refImgPath = previousImage.refImg.path;
+        const currentExpectedImgPath = image.expectedImg.path;
+        const shouldRemoveReference = _.isNull(previousImage.refImg.size);
+        let updatedImage, removedResult, referenceToRemove, referenceToUpdate;
+
+        await this._removeImageFromReport(reportPath, currentExpectedImgPath);
+        this._updateTestExpectedPath(fullTitle, browserName, stateName, previousExpectedImgPath);
+
+        if (shouldRemoveReference) {
+            referenceToRemove = refImgPath;
+        } else {
+            referenceToUpdate = {path: refImgPath, source: previousExpectedImgPath};
+        }
+
+        if (resultIdToRemove) {
+            this._testsTree.removeTestResult(resultIdToRemove);
+            this._decreaseTestAttemptNumber(fullTitle, browserName);
+
+            removedResult = resultIdToRemove;
+        } else {
+            updatedImage = this._testsTree.updateImageInfo(imageId, previousImage);
+        }
+
+        this._deleteTestResultFromDb({where: [
+            `${DB_COLUMNS.SUITE_PATH} = ?`,
+            `${DB_COLUMNS.NAME} = ?`,
+            `${DB_COLUMNS.STATUS} = ?`,
+            `${DB_COLUMNS.TIMESTAMP} = ?`,
+            `json_extract(${DB_COLUMNS.IMAGES_INFO}, '$[0].stateName') = ?`
+        ].join(' AND ')}, JSON.stringify(suitePath), browserName, status, timestamp, stateName);
+
+        return {updatedImage, removedResult, referenceToRemove, referenceToUpdate};
+    }
+
     _addTestResult(formattedResult, props, opts = {}) {
         super._addTestResult(formattedResult, props);
 
@@ -156,4 +231,10 @@ module.exports = class GuiReportBuilder extends StaticReportBuilder {
             });
         }
     }
+
+    async _removeImageFromReport(reportPath, imgPath) {
+        const imageAbsolutePath = path.resolve(process.cwd(), reportPath, imgPath);
+
+        await deleteFile(imageAbsolutePath);
+    }
 };

lib/report-builder/static.js

@@ -143,6 +143,18 @@ module.exports = class StaticReportBuilder {
         this._sqliteAdapter.write({testResult, suitePath, suiteName});
     }
 
+    _deleteTestResultFromDb({where, orderBy, orderDescending, limit}, ...args) {
+        this._sqliteAdapter.delete({where, orderBy, orderDescending, limit}, ...args);
+    }
+
+    _updateTestExpectedPath(fullTitle, browserId, stateName, expectedPath) {
+        TestAdapter.updateCacheExpectedPath(fullTitle, browserId, stateName, expectedPath);
+    }
+
+    _decreaseTestAttemptNumber(fullTitle, browserName) {
+        TestAdapter.decreaseAttemptNumber(fullTitle, browserName);
+    }
+
     async finalize() {
         this._sqliteAdapter.close();
 

lib/reporter-helpers.js

@@ -16,3 +16,13 @@ exports.updateReferenceImage = (testResult, reportPath, stateName) => {
         utils.copyFileAsync(src, utils.getReferenceAbsolutePath(testResult, reportPath, stateName))
     ]);
 };
+
+exports.removeReferenceImage = (refImgPaths) => {
+    return Promise.map([].concat(refImgPaths), (refImgPath) => utils.deleteFile(refImgPath));
+};
+
+exports.overwriteReferenceImage = (referencesToUpdate, reportPath) => {
+    return Promise.map([].concat(referencesToUpdate), (referenceToUpdate) => {
+        return utils.copyFileAsync(path.resolve(reportPath, referenceToUpdate.source), referenceToUpdate.path);
+    });
+};

lib/server-utils.js

@@ -52,6 +52,14 @@ function copyFileAsync(srcPath, destPath, reportDir = '') {
     return makeDirFor(resolvedDestPath).then(() => fs.copy(srcPath, resolvedDestPath));
 }
 
+/**
+ * @param {String} filePath
+ * @returns {Promise}
+ */
+function deleteFile(filePath) {
+    return fs.remove(filePath);
+}
+
 /**
  * @param {String} destPath
  */
@@ -268,6 +276,7 @@ module.exports = {
     getDiffAbsolutePath,
 
     copyFileAsync,
+    deleteFile,
     makeDirFor,
 
     logPathToHtmlReport,

lib/sqlite-adapter.js

@@ -6,7 +6,7 @@ const Database = require('better-sqlite3');
 const NestedError = require('nested-error-stacks');
 const debug = require('debug')('html-reporter:sqlite-adapter');
 
-const {getShortMD5} = require('./gui/tool-runner/utils.js');
+const {getShortMD5} = require('./common-utils');
 const {createTablesQuery} = require('./db-utils/server');
 const {DB_SUITES_TABLE_NAME, SUITES_TABLE_COLUMNS, LOCAL_DATABASE_NAME, DATABASE_URLS_JSON_NAME} = require('./constants/database');
 
@@ -62,27 +62,21 @@ module.exports = class SqliteAdapter {
      * @param {string} queryParams.where - `WHERE ${where}`
      * @param {string} queryParams.orderBy - `ORDER BY ${orderBy}`
      * @param {boolean} queryParams.orderDescending - ASCending / DESCending
+     * @param {number} queryParams.limit - `LIMIT ${limit}`
      * @param {boolean} queryParams.noCache - disables caching for equal queries
      * @param {...string} queryArgs
      */
-    query({select, where, orderBy, orderDescending, noCache = false} = {}, ...queryArgs) {
+    query({select, where, orderBy, orderDescending, limit, noCache = false} = {}, ...queryArgs) {
         const cacheKey = !noCache && getShortMD5(`${select}#${where}#${orderBy}${orderDescending}${queryArgs.join('#')}`);
 
         if (!noCache && this._queryCache.has(cacheKey)) {
             return this._queryCache.get(cacheKey);
         }
 
-        let query = `SELECT ${select || '*'} FROM ${DB_SUITES_TABLE_NAME}`;
+        const sentence = `SELECT ${select || '*'} FROM ${DB_SUITES_TABLE_NAME}`
+            + this._createSentence({where, orderBy, orderDescending, limit});
 
-        if (where) {
-            query += ` WHERE ${where}`;
-        }
-
-        if (orderBy) {
-            query += ` ORDER BY ${orderBy} ${orderDescending ? 'DESC' : 'ASC'}`;
-        }
-
-        const result = this._db.prepare(query).get(...queryArgs);
+        const result = this._db.prepare(sentence).get(...queryArgs);
 
         if (!noCache) {
             this._queryCache.set(cacheKey, result);
@@ -99,6 +93,40 @@ module.exports = class SqliteAdapter {
         this._db.prepare(`INSERT INTO ${DB_SUITES_TABLE_NAME} VALUES (${placeholders})`).run(...values);
     }
 
+    /**
+     * Delete records from database
+     * @param {Object} deleteParams
+     * @param {string} deleteParams.where - `WHERE ${where}`
+     * @param {string} deleteParams.orderBy - `ORDER BY ${orderBy}`
+     * @param {boolean} deleteParams.orderDescending - ASCending / DESCending
+     * @param {number} deleteParams.limit - `LIMIT ${limit}`
+     * @param {...string} deleteArgs
+     */
+    delete({where, orderBy, orderDescending, limit} = {}, ...deleteArgs) {
+        const sentence = `DELETE FROM ${DB_SUITES_TABLE_NAME}`
+            + this._createSentence({where, orderBy, orderDescending, limit});
+
+        this._db.prepare(sentence).run(...deleteArgs);
+    }
+
+    _createSentence({where, orderBy, orderDescending, limit}) {
+        let sentence = '';
+
+        if (where) {
+            sentence += ` WHERE ${where}`;
+        }
+
+        if (orderBy) {
+            sentence += ` ORDER BY ${orderBy} ${orderDescending ? 'DESC' : 'ASC'}`;
+        }
+
+        if (limit) {
+            sentence += ` LIMIT ${limit}`;
+        }
+
+        return sentence;
+    }
+
     _parseTestResult({suitePath, suiteName, testResult}) {
         const {
             name,