@appium/support 2.54.2 → 2.55.3

package/build/test/fs-specs.js

@@ -0,0 +1,264 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _index = require("../lib/index.js");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _teen_process = require("teen_process");
+
+var _bluebird = _interopRequireDefault(require("bluebird"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+const MOCHA_TIMEOUT = 20000;
+describe('fs', function () {
+  this.timeout(MOCHA_TIMEOUT);
+
+  const existingPath = _path.default.resolve(__dirname, 'fs-specs.js');
+
+  it('should have expected methods', function () {
+    should.exist(_index.fs.open);
+    should.exist(_index.fs.close);
+    should.exist(_index.fs.access);
+    should.exist(_index.fs.mkdir);
+    should.exist(_index.fs.readlink);
+    should.exist(_index.fs.exists);
+    should.exist(_index.fs.rimraf);
+    should.exist(_index.fs.rimrafSync);
+    should.exist(_index.fs.readFile);
+    should.exist(_index.fs.writeFile);
+    should.exist(_index.fs.lstat);
+    should.exist(_index.fs.mv);
+  });
+  describe('mkdir', function () {
+    let dirName = _path.default.resolve(__dirname, 'tmp');
+
+    it('should make a directory that does not exist', async function () {
+      await _index.fs.rimraf(dirName);
+      await _index.fs.mkdir(dirName);
+      let exists = await _index.fs.hasAccess(dirName);
+      exists.should.be.true;
+    });
+    it('should not complain if the dir already exists', async function () {
+      let exists = await _index.fs.hasAccess(dirName);
+      exists.should.be.true;
+      await _index.fs.mkdir(dirName);
+    });
+    it('should still throw an error if something else goes wrong', async function () {
+      await _index.fs.mkdir('/bin/foo').should.be.rejected;
+    });
+  });
+  it('hasAccess', async function () {
+    (await _index.fs.exists(existingPath)).should.be.ok;
+
+    let nonExistingPath = _path.default.resolve(__dirname, 'wrong-specs.js');
+
+    (await _index.fs.hasAccess(nonExistingPath)).should.not.be.ok;
+  });
+  it('exists', async function () {
+    (await _index.fs.exists(existingPath)).should.be.ok;
+
+    let nonExistingPath = _path.default.resolve(__dirname, 'wrong-specs.js');
+
+    (await _index.fs.exists(nonExistingPath)).should.not.be.ok;
+  });
+  it('readFile', async function () {
+    (await _index.fs.readFile(existingPath, 'utf8')).should.contain('readFile');
+  });
+  describe('copyFile', function () {
+    it('should be able to copy a file', async function () {
+      let newPath = _path.default.resolve(await _index.tempDir.openDir(), 'fs-specs.js');
+
+      await _index.fs.copyFile(existingPath, newPath);
+      (await _index.fs.readFile(newPath, 'utf8')).should.contain('readFile');
+    });
+    it('should throw an error if the source does not exist', async function () {
+      await _index.fs.copyFile('/sdfsdfsdfsdf', '/tmp/bla').should.eventually.be.rejected;
+    });
+  });
+  it('rimraf', async function () {
+    let newPath = _path.default.resolve(await _index.tempDir.openDir(), 'fs-specs.js');
+
+    await _index.fs.copyFile(existingPath, newPath);
+    (await _index.fs.exists(newPath)).should.be.true;
+    await _index.fs.rimraf(newPath);
+    (await _index.fs.exists(newPath)).should.be.false;
+  });
+  it('sanitizeName', function () {
+    _index.fs.sanitizeName(':file?.txt', {
+      replacement: '-'
+    }).should.eql('-file-.txt');
+  });
+  it('rimrafSync', async function () {
+    let newPath = _path.default.resolve(await _index.tempDir.openDir(), 'fs-specs.js');
+
+    await _index.fs.copyFile(existingPath, newPath);
+    (await _index.fs.exists(newPath)).should.be.true;
+
+    _index.fs.rimrafSync(newPath);
+
+    (await _index.fs.exists(newPath)).should.be.false;
+  });
+  describe('md5', function () {
+    this.timeout(1200000);
+    let smallFilePath;
+    let bigFilePath;
+    before(async function () {
+      smallFilePath = existingPath;
+      bigFilePath = _path.default.resolve(await _index.tempDir.openDir(), 'enormous.txt');
+      let file = await _index.fs.open(bigFilePath, 'w');
+      let fileData = '';
+
+      for (let i = 0; i < 4096; i++) {
+        fileData += '1';
+      }
+
+      for (let i = 0; i < 40000; i++) {
+        await _index.fs.write(file, fileData);
+      }
+
+      await _index.fs.close(file);
+    });
+    after(async function () {
+      await _index.fs.unlink(bigFilePath);
+    });
+    it('should calculate hash of correct length', async function () {
+      (await _index.fs.md5(smallFilePath)).should.have.length(32);
+    });
+    it('should be able to run on huge file', async function () {
+      (await _index.fs.md5(bigFilePath)).should.have.length(32);
+    });
+  });
+  describe('hash', function () {
+    it('should calculate sha1 hash', async function () {
+      (await _index.fs.hash(existingPath, 'sha1')).should.have.length(40);
+    });
+    it('should calculate md5 hash', async function () {
+      (await _index.fs.hash(existingPath, 'md5')).should.have.length(32);
+    });
+  });
+  it('stat', async function () {
+    let stat = await _index.fs.stat(existingPath);
+    stat.should.have.property('atime');
+  });
+  describe('which', function () {
+    it('should find correct executable', async function () {
+      let systemNpmPath = (await (0, _teen_process.exec)('which', ['npm'])).stdout.trim();
+      let npmPath = await _index.fs.which('npm');
+      npmPath.should.equal(systemNpmPath);
+    });
+    it('should fail gracefully', async function () {
+      await _index.fs.which('something_that_does_not_exist').should.eventually.be.rejected;
+    });
+  });
+  it('glob', async function () {
+    let glob = '*-specs.js';
+    let tests = await _index.fs.glob(glob, {
+      cwd: __dirname
+    });
+    tests.should.be.an('array');
+    tests.should.have.length.above(2);
+  });
+  describe('walkDir', function () {
+    it('walkDir recursive', async function () {
+      let inCallback = 0;
+      const filePath = await _index.fs.walkDir(__dirname, true, async item => {
+        if (item.endsWith('logger/helpers.js')) {
+          ++inCallback;
+          await _bluebird.default.delay(500);
+          --inCallback;
+          return true;
+        }
+      });
+      inCallback.should.equal(0);
+      filePath.should.not.be.null;
+    });
+    it('should walk all elements recursive', async function () {
+      let inCallback = 0;
+      const filePath = await _index.fs.walkDir(__dirname, true, async () => {
+        ++inCallback;
+        await _bluebird.default.delay(500);
+        --inCallback;
+      });
+      inCallback.should.equal(0);
+      _lodash.default.isNil(filePath).should.be.true;
+    });
+    it('should throw error through callback', async function () {
+      let processed = 0;
+      await chai.expect(_index.fs.walkDir(__dirname, true, () => {
+        ++processed;
+        throw 'Callback error';
+      })).to.be.rejectedWith('Callback error');
+      processed.should.equal(1);
+    });
+    it('should traverse non-recursively', async function () {
+      const filePath = await _index.fs.walkDir(__dirname, false, item => item.endsWith('logger/helpers.js'));
+      _lodash.default.isNil(filePath).should.be.true;
+    });
+  });
+  describe('findRoot()', function () {
+    describe('when not provided an argument', function () {
+      it('should throw', function () {
+        (() => _index.fs.findRoot()).should.throw(TypeError);
+      });
+    });
+    describe('when provided a relative path', function () {
+      it('should throw', function () {
+        (() => _index.fs.findRoot('./foo')).should.throw(TypeError);
+      });
+    });
+    describe('when provided an empty string', function () {
+      it('should throw', function () {
+        (() => _index.fs.findRoot('')).should.throw(TypeError);
+      });
+    });
+    describe('when provided an absolute path', function () {
+      describe('when the path has a parent `package.json`', function () {
+        it('should locate the dir with the closest `package.json`', function () {
+          _index.fs.findRoot(__dirname).should.be.a('string');
+        });
+      });
+      describe('when the path does not have a parent `package.json`', function () {
+        it('should throw', function () {
+          (() => _index.fs.findRoot('/')).should.throw(Error);
+        });
+      });
+    });
+  });
+  describe('readPackageJsonFrom()', function () {
+    describe('when not provided an argument', function () {
+      it('should throw', function () {
+        (() => _index.fs.readPackageJsonFrom()).should.throw(TypeError, /non-empty, absolute path/);
+      });
+    });
+    describe('when provided a relative path', function () {
+      it('should throw', function () {
+        (() => _index.fs.readPackageJsonFrom('./foo')).should.throw(TypeError);
+      });
+    });
+    describe('when provided an empty string', function () {
+      it('should throw', function () {
+        (() => _index.fs.readPackageJsonFrom('')).should.throw(TypeError);
+      });
+    });
+    describe('when provided an absolute path', function () {
+      describe('when the path does not have a parent `package.json`', function () {
+        it('should throw', function () {
+          (() => _index.fs.readPackageJsonFrom('/')).should.throw(Error);
+        });
+      });
+      describe('when the path has a parent `package.json`', function () {
+        it('should read the `package.json` found in the root dir', function () {
+          _index.fs.readPackageJsonFrom(__dirname).should.be.an('object');
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/fs-specs.js"],"names":["MOCHA_TIMEOUT","describe","timeout","existingPath","path","resolve","__dirname","it","should","exist","fs","open","close","access","mkdir","readlink","exists","rimraf","rimrafSync","readFile","writeFile","lstat","mv","dirName","hasAccess","be","true","rejected","ok","nonExistingPath","not","contain","newPath","tempDir","openDir","copyFile","eventually","false","sanitizeName","replacement","eql","smallFilePath","bigFilePath","before","file","fileData","i","write","after","unlink","md5","have","length","hash","stat","property","systemNpmPath","stdout","trim","npmPath","which","equal","glob","tests","cwd","an","above","inCallback","filePath","walkDir","item","endsWith","B","delay","null","_","isNil","processed","chai","expect","to","rejectedWith","findRoot","throw","TypeError","a","Error","readPackageJsonFrom"],"mappings":"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","sourcesContent":["import { fs, tempDir } from '../lib/index.js';\nimport path from 'path';\nimport { exec } from 'teen_process';\nimport B from 'bluebird';\nimport _ from 'lodash';\n\n\nconst MOCHA_TIMEOUT = 20000;\n\ndescribe('fs', function () {\n  this.timeout(MOCHA_TIMEOUT);\n\n  const existingPath = path.resolve(__dirname, 'fs-specs.js');\n\n  it('should have expected methods', function () {\n    should.exist(fs.open);\n    should.exist(fs.close);\n    should.exist(fs.access);\n    should.exist(fs.mkdir);\n    should.exist(fs.readlink);\n    should.exist(fs.exists);\n    should.exist(fs.rimraf);\n    should.exist(fs.rimrafSync);\n    should.exist(fs.readFile);\n    should.exist(fs.writeFile);\n    should.exist(fs.lstat);\n    should.exist(fs.mv);\n  });\n\n  describe('mkdir', function () {\n    let dirName = path.resolve(__dirname, 'tmp');\n\n    it('should make a directory that does not exist', async function () {\n      await fs.rimraf(dirName);\n      await fs.mkdir(dirName);\n      let exists = await fs.hasAccess(dirName);\n      exists.should.be.true;\n    });\n\n    it('should not complain if the dir already exists', async function () {\n      let exists = await fs.hasAccess(dirName);\n      exists.should.be.true;\n      await fs.mkdir(dirName);\n    });\n\n    it('should still throw an error if something else goes wrong', async function () {\n      await fs.mkdir('/bin/foo').should.be.rejected;\n    });\n  });\n\n  it('hasAccess', async function () {\n    (await fs.exists(existingPath)).should.be.ok;\n    let nonExistingPath = path.resolve(__dirname, 'wrong-specs.js');\n    (await fs.hasAccess(nonExistingPath)).should.not.be.ok;\n  });\n  it('exists', async function () {\n    (await fs.exists(existingPath)).should.be.ok;\n    let nonExistingPath = path.resolve(__dirname, 'wrong-specs.js');\n    (await fs.exists(nonExistingPath)).should.not.be.ok;\n  });\n  it('readFile', async function () {\n    (await fs.readFile(existingPath, 'utf8')).should.contain('readFile');\n  });\n\n  describe('copyFile', function () {\n    it('should be able to copy a file', async function () {\n      let newPath = path.resolve(await tempDir.openDir(), 'fs-specs.js');\n      await fs.copyFile(existingPath, newPath);\n      (await fs.readFile(newPath, 'utf8')).should.contain('readFile');\n    });\n\n    it('should throw an error if the source does not exist', async function () {\n      await fs.copyFile('/sdfsdfsdfsdf', '/tmp/bla').should.eventually.be.rejected;\n    });\n  });\n\n  it('rimraf', async function () {\n    let newPath = path.resolve(await tempDir.openDir(), 'fs-specs.js');\n    await fs.copyFile(existingPath, newPath);\n    (await fs.exists(newPath)).should.be.true;\n    await fs.rimraf(newPath);\n    (await fs.exists(newPath)).should.be.false;\n  });\n  it('sanitizeName', function () {\n    fs.sanitizeName(':file?.txt', {\n      replacement: '-',\n    }).should.eql('-file-.txt');\n  });\n  it('rimrafSync', async function () {\n    let newPath = path.resolve(await tempDir.openDir(), 'fs-specs.js');\n    await fs.copyFile(existingPath, newPath);\n    (await fs.exists(newPath)).should.be.true;\n    fs.rimrafSync(newPath);\n    (await fs.exists(newPath)).should.be.false;\n  });\n  describe('md5', function () {\n    this.timeout(1200000);\n    let smallFilePath;\n    let bigFilePath;\n    before(async function () {\n      // get the path of a small file (this source file)\n      smallFilePath = existingPath;\n\n      // create a large file to test, about 163840000 bytes\n      bigFilePath = path.resolve(await tempDir.openDir(), 'enormous.txt');\n      let file = await fs.open(bigFilePath, 'w');\n      let fileData = '';\n      for (let i = 0; i < 4096; i++) {\n        fileData += '1';\n      }\n      for (let i = 0; i < 40000; i++) {\n        await fs.write(file, fileData);\n      }\n      await fs.close(file);\n    });\n    after(async function () {\n      await fs.unlink(bigFilePath);\n    });\n    it('should calculate hash of correct length', async function () {\n      (await fs.md5(smallFilePath)).should.have.length(32);\n    });\n    it('should be able to run on huge file', async function () {\n      (await fs.md5(bigFilePath)).should.have.length(32);\n    });\n  });\n  describe('hash', function () {\n    it('should calculate sha1 hash', async function () {\n      (await fs.hash(existingPath, 'sha1')).should.have.length(40);\n    });\n    it('should calculate md5 hash', async function () {\n      (await fs.hash(existingPath, 'md5')).should.have.length(32);\n    });\n  });\n  it('stat', async function () {\n    let stat = await fs.stat(existingPath);\n    stat.should.have.property('atime');\n  });\n  describe('which', function () {\n    it('should find correct executable', async function () {\n      let systemNpmPath = (await exec('which', ['npm'])).stdout.trim();\n      let npmPath = await fs.which('npm');\n      npmPath.should.equal(systemNpmPath);\n    });\n    it('should fail gracefully', async function () {\n      await fs.which('something_that_does_not_exist')\n        .should.eventually.be.rejected;\n    });\n  });\n  it('glob', async function () {\n    let glob = '*-specs.js';\n    let tests = await fs.glob(glob, {cwd: __dirname});\n    tests.should.be.an('array');\n    tests.should.have.length.above(2);\n  });\n  describe('walkDir', function () {\n    it('walkDir recursive', async function () {\n      let inCallback = 0;\n      const filePath = await fs.walkDir(__dirname, true, async (item) => {\n        if (item.endsWith('logger/helpers.js')) {\n          ++inCallback;\n          // This is to verify proper await functionality of the\n          // callback invocation inside the file system walker\n          await B.delay(500);\n          --inCallback;\n          return true;\n        }\n      });\n      inCallback.should.equal(0);\n      filePath.should.not.be.null;\n    });\n    it('should walk all elements recursive', async function () {\n      let inCallback = 0;\n      const filePath = await fs.walkDir(__dirname, true, async () => {\n        ++inCallback;\n        await B.delay(500);\n        --inCallback;\n\n      });\n      inCallback.should.equal(0);\n      _.isNil(filePath).should.be.true;\n    });\n    it('should throw error through callback', async function () {\n      let processed = 0;\n      await chai.expect(fs.walkDir(__dirname, true,\n        () => {\n          ++processed;\n          throw 'Callback error';\n        })).to.be.rejectedWith('Callback error');\n      processed.should.equal(1);\n    });\n    it('should traverse non-recursively', async function () {\n      const filePath = await fs.walkDir(__dirname, false, (item) => item.endsWith('logger/helpers.js'));\n      _.isNil(filePath).should.be.true;\n    });\n  });\n\n  describe('findRoot()', function () {\n    describe('when not provided an argument', function () {\n      it('should throw', function () {\n        (() => fs.findRoot()).should.throw(TypeError);\n      });\n    });\n\n    describe('when provided a relative path', function () {\n      it('should throw', function () {\n        (() => fs.findRoot('./foo')).should.throw(TypeError);\n      });\n    });\n\n    describe('when provided an empty string', function () {\n      it('should throw', function () {\n        (() => fs.findRoot('')).should.throw(TypeError);\n      });\n    });\n\n    describe('when provided an absolute path', function () {\n      describe('when the path has a parent `package.json`', function () {\n        it('should locate the dir with the closest `package.json`', function () {\n          fs.findRoot(__dirname).should.be.a('string');\n        });\n      });\n\n      describe('when the path does not have a parent `package.json`', function () {\n        it('should throw', function () {\n          (() => fs.findRoot('/')).should.throw(Error);\n        });\n      });\n    });\n  });\n\n  describe('readPackageJsonFrom()', function () {\n    describe('when not provided an argument', function () {\n      it('should throw', function () {\n        (() => fs.readPackageJsonFrom()).should.throw(TypeError, /non-empty, absolute path/);\n      });\n    });\n\n    describe('when provided a relative path', function () {\n      it('should throw', function () {\n        (() => fs.readPackageJsonFrom('./foo')).should.throw(TypeError);\n      });\n    });\n\n    describe('when provided an empty string', function () {\n      it('should throw', function () {\n        (() => fs.readPackageJsonFrom('')).should.throw(TypeError);\n      });\n    });\n\n    describe('when provided an absolute path', function () {\n      describe('when the path does not have a parent `package.json`', function () {\n        it('should throw', function () {\n          (() => fs.readPackageJsonFrom('/')).should.throw(Error);\n        });\n      });\n\n      describe('when the path has a parent `package.json`', function () {\n        it('should read the `package.json` found in the root dir', function () {\n          fs.readPackageJsonFrom(__dirname).should.be.an('object');\n        });\n      });\n    });\n  });\n});\n"],"file":"test/fs-specs.js","sourceRoot":"../.."}

package/build/test/helpers.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MockReadWriteStream = void 0;
+
+require("source-map-support/register");
+
+var _events = require("events");
+
+class MockReadWriteStream extends _events.EventEmitter {
+  resume() {}
+
+  pause() {}
+
+  setEncoding() {}
+
+  flush() {}
+
+  write(msg) {
+    this.emit('data', msg);
+  }
+
+  end() {
+    this.emit('end');
+    this.emit('finish');
+  }
+
+}
+
+exports.MockReadWriteStream = MockReadWriteStream;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbInRlc3QvaGVscGVycy5qcyJdLCJuYW1lcyI6WyJNb2NrUmVhZFdyaXRlU3RyZWFtIiwiRXZlbnRFbWl0dGVyIiwicmVzdW1lIiwicGF1c2UiLCJzZXRFbmNvZGluZyIsImZsdXNoIiwid3JpdGUiLCJtc2ciLCJlbWl0IiwiZW5kIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQTs7QUFFQSxNQUFNQSxtQkFBTixTQUFrQ0Msb0JBQWxDLENBQStDO0FBQzdDQyxFQUFBQSxNQUFNLEdBQUksQ0FBRTs7QUFFWkMsRUFBQUEsS0FBSyxHQUFJLENBQUU7O0FBRVhDLEVBQUFBLFdBQVcsR0FBSSxDQUFFOztBQUVqQkMsRUFBQUEsS0FBSyxHQUFJLENBQUU7O0FBRVhDLEVBQUFBLEtBQUssQ0FBRUMsR0FBRixFQUFPO0FBQ1YsU0FBS0MsSUFBTCxDQUFVLE1BQVYsRUFBa0JELEdBQWxCO0FBQ0Q7O0FBRURFLEVBQUFBLEdBQUcsR0FBSTtBQUNMLFNBQUtELElBQUwsQ0FBVSxLQUFWO0FBQ0EsU0FBS0EsSUFBTCxDQUFVLFFBQVY7QUFDRDs7QUFoQjRDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRXZlbnRFbWl0dGVyIH0gZnJvbSAnZXZlbnRzJztcblxuY2xhc3MgTW9ja1JlYWRXcml0ZVN0cmVhbSBleHRlbmRzIEV2ZW50RW1pdHRlciB7XG4gIHJlc3VtZSAoKSB7fVxuXG4gIHBhdXNlICgpIHt9XG5cbiAgc2V0RW5jb2RpbmcgKCkge31cblxuICBmbHVzaCAoKSB7fVxuXG4gIHdyaXRlIChtc2cpIHtcbiAgICB0aGlzLmVtaXQoJ2RhdGEnLCBtc2cpO1xuICB9XG5cbiAgZW5kICgpIHtcbiAgICB0aGlzLmVtaXQoJ2VuZCcpO1xuICAgIHRoaXMuZW1pdCgnZmluaXNoJyk7XG4gIH1cbn1cblxuZXhwb3J0IHsgTW9ja1JlYWRXcml0ZVN0cmVhbSB9O1xuIl0sImZpbGUiOiJ0ZXN0L2hlbHBlcnMuanMiLCJzb3VyY2VSb290IjoiLi4vLi4ifQ==

package/build/test/image-util-e2e-specs.js

@@ -0,0 +1,227 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _imageUtil = require("../lib/image-util");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _lib = require("../lib");
+
+const FIXTURES_ROOT = _path.default.resolve(__dirname, '..', '..', 'test', 'images');
+
+async function getImage(name) {
+  const imagePath = _path.default.resolve(FIXTURES_ROOT, name);
+
+  return await _lib.fs.readFile(imagePath, 'utf8');
+}
+
+describe('image-util', function () {
+  before(function () {
+    return this.skip();
+  });
+  describe('cropBase64Image', function () {
+    let originalImage = null;
+    before(async function () {
+      const originalImage64 = await getImage('full-image.b64');
+      originalImage = await (0, _imageUtil.base64ToImage)(originalImage64);
+      originalImage.width.should.be.equal(640, 'unexpected width');
+      originalImage.height.should.be.equal(1136, 'unexpected height');
+    });
+    it('should verify that an image is cropped correctly', async function () {
+      const croppedImage = await (0, _imageUtil.cropImage)(originalImage, {
+        left: 35,
+        top: 107,
+        width: 323,
+        height: 485
+      });
+      croppedImage.width.should.be.equal(323, 'unexpected width');
+      croppedImage.height.should.be.equal(485, 'unexpected height');
+      const croppedImageShouldBe = await getImage('cropped-image.b64');
+      const croppedImage64 = await (0, _imageUtil.imageToBase64)(croppedImage);
+      croppedImage64.should.be.equal(croppedImageShouldBe);
+    });
+  });
+  describe('OpenCV helpers', function () {
+    this.timeout(120000);
+    let imgFixture = null;
+    let fullImage = null;
+    let partialImage = null;
+    let originalImage = null;
+    let changedImage = null;
+    let rotatedImage = null;
+    let numberImage = null;
+    before(async function () {
+      const imagePath = _path.default.resolve(FIXTURES_ROOT, 'full-image.b64');
+
+      imgFixture = Buffer.from(await _lib.fs.readFile(imagePath, 'binary'), 'base64');
+      fullImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'findwaldo.jpg'));
+      partialImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'waldo.jpg'));
+      originalImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'cc1.png'));
+      changedImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'cc2.png'));
+      numberImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'number5.png'));
+      rotatedImage = await _lib.fs.readFile(_path.default.resolve(FIXTURES_ROOT, 'cc_rotated.png'));
+    });
+    describe('getImagesMatches', function () {
+      it('should calculate the number of matches between two images', async function () {
+        for (const detectorName of ['AKAZE', 'ORB']) {
+          const {
+            count,
+            totalCount
+          } = await (0, _imageUtil.getImagesMatches)(fullImage, fullImage, {
+            detectorName
+          });
+          count.should.be.above(0);
+          totalCount.should.eql(count);
+        }
+      });
+      it('should visualize matches between two images', async function () {
+        const {
+          visualization
+        } = await (0, _imageUtil.getImagesMatches)(fullImage, fullImage, {
+          visualize: true
+        });
+        visualization.should.not.be.empty;
+      });
+      it('should visualize matches between two images and apply goodMatchesFactor', async function () {
+        const {
+          visualization,
+          points1,
+          rect1,
+          points2,
+          rect2
+        } = await (0, _imageUtil.getImagesMatches)(rotatedImage, originalImage, {
+          visualize: true,
+          matchFunc: 'BruteForceHamming',
+          goodMatchesFactor: 40
+        });
+        visualization.should.not.be.empty;
+        points1.length.should.be.above(4);
+        rect1.x.should.be.above(0);
+        rect1.y.should.be.above(0);
+        rect1.width.should.be.above(0);
+        rect1.height.should.be.above(0);
+        points2.length.should.be.above(4);
+        rect2.x.should.be.above(0);
+        rect2.y.should.be.above(0);
+        rect2.width.should.be.above(0);
+        rect2.height.should.be.above(0);
+      });
+    });
+    describe('getImagesSimilarity', function () {
+      it('should calculate the similarity score between two images', async function () {
+        const {
+          score
+        } = await (0, _imageUtil.getImagesSimilarity)(imgFixture, imgFixture);
+        score.should.be.above(0);
+      });
+      it('should visualize the similarity between two images', async function () {
+        const {
+          visualization
+        } = await (0, _imageUtil.getImagesSimilarity)(originalImage, changedImage, {
+          visualize: true
+        });
+        visualization.should.not.be.empty;
+      });
+    });
+    describe('getImageOccurrence', function () {
+      it('should calculate the partial image position in the full image', async function () {
+        const {
+          rect,
+          score
+        } = await (0, _imageUtil.getImageOccurrence)(fullImage, partialImage);
+        rect.x.should.be.above(0);
+        rect.y.should.be.above(0);
+        rect.width.should.be.above(0);
+        rect.height.should.be.above(0);
+        score.should.be.above(0);
+      });
+      it('should reject matches that fall below a threshold', async function () {
+        await (0, _imageUtil.getImageOccurrence)(fullImage, partialImage, {
+          threshold: 1.0
+        }).should.eventually.be.rejectedWith(/threshold/);
+      });
+      it('should visualize the partial image position in the full image', async function () {
+        const {
+          visualization
+        } = await (0, _imageUtil.getImageOccurrence)(fullImage, partialImage, {
+          visualize: true
+        });
+        visualization.should.not.be.empty;
+      });
+      describe('multiple', function () {
+        it('should return matches in the full image', async function () {
+          const {
+            multiple
+          } = await (0, _imageUtil.getImageOccurrence)(originalImage, numberImage, {
+            threshold: 0.8,
+            multiple: true
+          });
+          multiple.length.should.be.eq(3);
+
+          for (const result of multiple) {
+            result.rect.x.should.be.above(0);
+            result.rect.y.should.be.above(0);
+            result.rect.width.should.be.above(0);
+            result.rect.height.should.be.above(0);
+            result.score.should.be.above(0);
+          }
+        });
+        it('should reject matches that fall below a threshold', async function () {
+          await (0, _imageUtil.getImageOccurrence)(originalImage, numberImage, {
+            threshold: 1.0,
+            multiple: true
+          }).should.eventually.be.rejectedWith(/threshold/);
+        });
+        it('should visualize the partial image position in the full image', async function () {
+          const {
+            multiple
+          } = await (0, _imageUtil.getImageOccurrence)(originalImage, numberImage, {
+            visualize: true,
+            multiple: true
+          });
+
+          for (const result of multiple) {
+            result.visualization.should.not.be.empty;
+          }
+        });
+      });
+    });
+  });
+  describe('Jimp helpers', function () {
+    it('should get a jimp object using image buffer', async function () {
+      const base64Image = await getImage('cropped-image.b64');
+      const imageBuffer = Buffer.from(base64Image, 'base64');
+      const jimpImg = await (0, _imageUtil.getJimpImage)(imageBuffer);
+      jimpImg.hash().should.eql('80000000000');
+      jimpImg.bitmap.height.should.eql(485);
+      jimpImg.bitmap.width.should.eql(323);
+    });
+    it('should get a jimp object using b64 string', async function () {
+      const base64Image = await getImage('cropped-image.b64');
+      const jimpImg = await (0, _imageUtil.getJimpImage)(base64Image);
+      jimpImg.hash().should.eql('80000000000');
+      jimpImg.bitmap.height.should.eql(485);
+      jimpImg.bitmap.width.should.eql(323);
+    });
+    it('should error with incorrect data type', async function () {
+      await (0, _imageUtil.getJimpImage)(1234).should.eventually.be.rejectedWith(/string or buffer/);
+    });
+    it('should error with incorrect image data', async function () {
+      await (0, _imageUtil.getJimpImage)('foo').should.eventually.be.rejectedWith(/Could not find MIME for Buffer/);
+    });
+    it('should get an image buffer via the overridden getBuffer method', async function () {
+      const base64Image = await getImage('cropped-image.b64');
+      const jimpImg = await (0, _imageUtil.getJimpImage)(base64Image);
+      const buf = await jimpImg.getBuffer(_imageUtil.MIME_PNG);
+      _lodash.default.isBuffer(buf).should.be.true;
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/image-util-e2e-specs.js"],"names":["FIXTURES_ROOT","path","resolve","__dirname","getImage","name","imagePath","fs","readFile","describe","before","skip","originalImage","originalImage64","width","should","be","equal","height","it","croppedImage","left","top","croppedImageShouldBe","croppedImage64","timeout","imgFixture","fullImage","partialImage","changedImage","rotatedImage","numberImage","Buffer","from","detectorName","count","totalCount","above","eql","visualization","visualize","not","empty","points1","rect1","points2","rect2","matchFunc","goodMatchesFactor","length","x","y","score","rect","threshold","eventually","rejectedWith","multiple","eq","result","base64Image","imageBuffer","jimpImg","hash","bitmap","buf","getBuffer","MIME_PNG","_","isBuffer","true"],"mappings":"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","sourcesContent":["import {\n  base64ToImage, imageToBase64, cropImage,\n  getImagesMatches, getImagesSimilarity, getImageOccurrence,\n  getJimpImage, MIME_PNG,\n} from '../lib/image-util';\nimport path from 'path';\nimport _ from 'lodash';\nimport { fs } from '../lib';\n\n\nconst FIXTURES_ROOT = path.resolve(__dirname, '..', '..', 'test', 'images');\n\nasync function getImage (name) {\n  const imagePath = path.resolve(FIXTURES_ROOT, name);\n  return await fs.readFile(imagePath, 'utf8');\n}\n\ndescribe('image-util', function () {\n  before(function () {\n    // TODO: remove when opencv4nodejs is fixed\n    return this.skip();\n  });\n\n  describe('cropBase64Image', function () {\n    let originalImage = null;\n\n    before(async function () {\n      const originalImage64 = await getImage('full-image.b64');\n      originalImage = await base64ToImage(originalImage64);\n\n      // verify original image size, to be sure that original image is correct\n      originalImage.width.should.be.equal(640, 'unexpected width');\n      originalImage.height.should.be.equal(1136, 'unexpected height');\n    });\n\n    it('should verify that an image is cropped correctly', async function () {\n      const croppedImage = await cropImage(originalImage, {left: 35, top: 107, width: 323, height: 485});\n\n      // verify cropped image size, it should be less than original image according to crop region\n      croppedImage.width.should.be.equal(323, 'unexpected width');\n      croppedImage.height.should.be.equal(485, 'unexpected height');\n\n      // verify that image cropped, compare base64 representation\n      const croppedImageShouldBe = await getImage('cropped-image.b64');\n      const croppedImage64 = await imageToBase64(croppedImage);\n      croppedImage64.should.be.equal(croppedImageShouldBe);\n    });\n  });\n\n  describe('OpenCV helpers', function () {\n    // OpenCV needs several seconds for initialization\n    this.timeout(120000);\n\n    let imgFixture = null;\n    let fullImage = null;\n    let partialImage = null;\n    let originalImage = null;\n    let changedImage = null;\n    let rotatedImage = null;\n    let numberImage = null;\n\n    before(async function () {\n      const imagePath = path.resolve(FIXTURES_ROOT, 'full-image.b64');\n      imgFixture = Buffer.from(await fs.readFile(imagePath, 'binary'), 'base64');\n      fullImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'findwaldo.jpg'));\n      partialImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'waldo.jpg'));\n      originalImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'cc1.png'));\n      changedImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'cc2.png'));\n      numberImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'number5.png'));\n      rotatedImage = await fs.readFile(path.resolve(FIXTURES_ROOT, 'cc_rotated.png'));\n    });\n\n    describe('getImagesMatches', function () {\n      it('should calculate the number of matches between two images', async function () {\n        for (const detectorName of ['AKAZE', 'ORB']) {\n          const {count, totalCount} = await getImagesMatches(fullImage, fullImage, {detectorName});\n          count.should.be.above(0);\n          totalCount.should.eql(count);\n        }\n      });\n\n      it('should visualize matches between two images', async function () {\n        const {visualization} = await getImagesMatches(fullImage, fullImage, {visualize: true});\n        visualization.should.not.be.empty;\n      });\n\n      it('should visualize matches between two images and apply goodMatchesFactor', async function () {\n        const {visualization, points1, rect1, points2, rect2} = await getImagesMatches(rotatedImage, originalImage, {\n          visualize: true,\n          matchFunc: 'BruteForceHamming',\n          goodMatchesFactor: 40\n        });\n        visualization.should.not.be.empty;\n        points1.length.should.be.above(4);\n        rect1.x.should.be.above(0);\n        rect1.y.should.be.above(0);\n        rect1.width.should.be.above(0);\n        rect1.height.should.be.above(0);\n        points2.length.should.be.above(4);\n        rect2.x.should.be.above(0);\n        rect2.y.should.be.above(0);\n        rect2.width.should.be.above(0);\n        rect2.height.should.be.above(0);\n      });\n    });\n\n    describe('getImagesSimilarity', function () {\n      it('should calculate the similarity score between two images', async function () {\n        const {score} = await getImagesSimilarity(imgFixture, imgFixture);\n        score.should.be.above(0);\n      });\n\n      it('should visualize the similarity between two images', async function () {\n        const {visualization} = await getImagesSimilarity(originalImage, changedImage, {visualize: true});\n        visualization.should.not.be.empty;\n      });\n    });\n\n    describe('getImageOccurrence', function () {\n      it('should calculate the partial image position in the full image', async function () {\n        const {rect, score} = await getImageOccurrence(fullImage, partialImage);\n        rect.x.should.be.above(0);\n        rect.y.should.be.above(0);\n        rect.width.should.be.above(0);\n        rect.height.should.be.above(0);\n        score.should.be.above(0);\n      });\n\n      it('should reject matches that fall below a threshold', async function () {\n        await getImageOccurrence(fullImage, partialImage, {threshold: 1.0})\n          .should.eventually.be.rejectedWith(/threshold/);\n      });\n\n      it('should visualize the partial image position in the full image', async function () {\n        const {visualization} = await getImageOccurrence(fullImage, partialImage, {visualize: true});\n        visualization.should.not.be.empty;\n      });\n\n      describe('multiple', function () {\n        it('should return matches in the full image', async function () {\n          const { multiple } = await getImageOccurrence(originalImage, numberImage, {threshold: 0.8, multiple: true});\n          multiple.length.should.be.eq(3);\n\n          for (const result of multiple) {\n            result.rect.x.should.be.above(0);\n            result.rect.y.should.be.above(0);\n            result.rect.width.should.be.above(0);\n            result.rect.height.should.be.above(0);\n            result.score.should.be.above(0);\n          }\n        });\n\n        it('should reject matches that fall below a threshold', async function () {\n          await getImageOccurrence(originalImage, numberImage, {threshold: 1.0, multiple: true})\n            .should.eventually.be.rejectedWith(/threshold/);\n        });\n\n        it('should visualize the partial image position in the full image', async function () {\n          const { multiple } = await getImageOccurrence(originalImage, numberImage, {visualize: true, multiple: true});\n\n          for (const result of multiple) {\n            result.visualization.should.not.be.empty;\n          }\n        });\n      });\n    });\n  });\n\n  describe('Jimp helpers', function () {\n    it('should get a jimp object using image buffer', async function () {\n      const base64Image = await getImage('cropped-image.b64');\n      const imageBuffer = Buffer.from(base64Image, 'base64');\n      const jimpImg = await getJimpImage(imageBuffer);\n      jimpImg.hash().should.eql('80000000000');\n      jimpImg.bitmap.height.should.eql(485);\n      jimpImg.bitmap.width.should.eql(323);\n    });\n    it('should get a jimp object using b64 string', async function () {\n      const base64Image = await getImage('cropped-image.b64');\n      const jimpImg = await getJimpImage(base64Image);\n      jimpImg.hash().should.eql('80000000000');\n      jimpImg.bitmap.height.should.eql(485);\n      jimpImg.bitmap.width.should.eql(323);\n    });\n    it('should error with incorrect data type', async function () {\n      await getJimpImage(1234).should.eventually.be.rejectedWith(/string or buffer/);\n    });\n    it('should error with incorrect image data', async function () {\n      await getJimpImage('foo').should.eventually.be.rejectedWith(/Could not find MIME for Buffer/);\n    });\n    it('should get an image buffer via the overridden getBuffer method', async function () {\n      const base64Image = await getImage('cropped-image.b64');\n      const jimpImg = await getJimpImage(base64Image);\n      const buf = await jimpImg.getBuffer(MIME_PNG);\n      _.isBuffer(buf).should.be.true;\n    });\n  });\n});\n"],"file":"test/image-util-e2e-specs.js","sourceRoot":"../.."}