How to use zip.assertValidZip method in Appium Base Driver

Best JavaScript code snippet using appium-base-driver

helpers.js

Source:helpers.js

...237  }238  return result;239}240async function unzipApp (zipPath, dstRoot, supportedAppExtensions) {241  await zip.assertValidZip(zipPath);242  if (!_.isArray(supportedAppExtensions)) {243    supportedAppExtensions = [supportedAppExtensions];244  }245  const tmpRoot = await tempDir.openDir();246  try {247    logger.debug(`Unzipping '${zipPath}'`);248    await zip.extractAllTo(zipPath, tmpRoot);249    const allExtractedItems = await walkDir(tmpRoot);250    logger.debug(`Extracted ${allExtractedItems.length} item(s) from '${zipPath}'`);251    const isSupportedAppItem = (relativePath) => supportedAppExtensions.includes(path.extname(relativePath))252      || _.some(supportedAppExtensions, (x) => relativePath.includes(`${x}${path.sep}`));253    const itemsToKeep = allExtractedItems254      .map((itemPath) => path.relative(tmpRoot, itemPath))255      .filter((relativePath) => isSupportedAppItem(relativePath))...

android-manifest.js

Source:android-manifest.js

...168 *                          The file will be overridden if it already exists.169 */170manifestMethods.insertManifest = async function insertManifest (manifest, srcApk, dstApk) {171  log.debug(`Inserting manifest '${manifest}', src: '${srcApk}', dst: '${dstApk}'`);172  await zip.assertValidZip(srcApk);173  await unzipFile(`${manifest}.apk`);174  const manifestName = path.basename(manifest);175  try {176    await this.initAapt();177    await fs.copyFile(srcApk, dstApk);178    log.debug('Moving manifest');179    try {180      await exec(this.binaries.aapt, [181        'remove', dstApk, manifestName182      ]);183    } catch (ign) {}184    await exec(this.binaries.aapt, [185      'add', dstApk, manifestName186    ], {cwd: path.dirname(manifest)});...

zip-e2e-specs.js

Source:zip-e2e-specs.js

...33    });34  });35  describe('assertValidZip', function () {36    it('should not throw an error if a valid ZIP file is passed', async function () {37      await zip.assertValidZip(zippedFilePath).should.eventually.be.fulfilled;38    });39    it('should throw an error if the file does not exist', async function () {40      await zip.assertValidZip('blabla').should.eventually.be.rejected;41    });42    it('should throw an error if the file is invalid', async function () {43      await zip.assertValidZip(path.resolve(assetsPath, 'unzipped', 'test-dir', 'a.txt')).should.eventually.be.rejected;44    });45  });46  describe('readEntries()', function () {47    const expectedEntries = [48      {name: 'unzipped/'},49      {name: 'unzipped/test-dir/'},50      {name: 'unzipped/test-dir/a.txt', contents: 'Hello World'},51      {name: 'unzipped/test-dir/b.txt', contents: 'Foo Bar'},52    ];53    it('should iterate entries (directories and files) of zip file', async function () {54      let i = 0;55      await zip.readEntries(zippedFilePath, async ({entry, extractEntryTo}) => {56        entry.fileName.should.equal(expectedEntries[i].name);57        // If it's a file, test that we can extract it to a temporary directory and that the contents are correct...

zip.js

Source:zip.js

1import B from 'bluebird';2import nodeExtract from 'extract-zip';3import yauzl from 'yauzl';4import archiver from 'archiver';5import { createWriteStream } from 'fs';6import path from 'path';7import { mkdirp } from '../lib/mkdirp';8import stream from 'stream';9import fs from './fs';10const extract = B.promisify(nodeExtract);11const open = B.promisify(yauzl.open);12const ZIP_MAGIC = 'PK';13/**14 * Extract zipfile to a directory15 *16 * @param {string} zipFilePath The full path to the source ZIP file17 * @param {string} destDir The full path to the destination folder18 */19async function extractAllTo (zipFilePath, destDir) {20  return await extract(zipFilePath, {dir: destDir});21}22/**23 * Extract a single zip entry to a directory24 *25 * @param {Streamable} zipFile The source ZIP stream26 * @param {yauzl.ZipEntry} entry The entry instance27 * @param {string} destDir The full path to the destination folder28 */29async function _extractEntryTo (zipFile, entry, destDir) {30  const dstPath = path.resolve(destDir, entry.fileName);31  // Create dest directory if doesn't exist already32  if (/\/$/.test(entry.fileName)) {33    if (!await fs.exists(dstPath)) {34      await mkdirp(dstPath);35    }36    return;37  } else if (!await fs.exists(path.dirname(dstPath))) {38    await mkdirp(path.dirname(dstPath));39  }40  // Create a write stream41  const writeStream = createWriteStream(dstPath, {flags: 'w'});42  const writeStreamPromise = new B((resolve, reject) => {43    writeStream.once('finish', resolve);44    writeStream.once('error', reject);45  });46  // Create zipReadStream and pipe data to the write stream47  // (for some odd reason B.promisify doesn't work on zipfile.openReadStream, it causes an error 'closed')48  const zipReadStream = await new B((resolve, reject) => {49    zipFile.openReadStream(entry, (err, readStream) => err ? reject(err) : resolve(readStream));50  });51  const zipReadStreamPromise = new B((resolve, reject) => {52    zipReadStream.once('end', resolve);53    zipReadStream.once('error', reject);54  });55  zipReadStream.pipe(writeStream);56  // Wait for the zipReadStream and writeStream to end before returning57  return await B.all([58    zipReadStreamPromise,59    writeStreamPromise,60  ]);61}62/**63 * @typedef {Object} ZipEntry64 * @property {yauzl.ZipEntry} entry The actual entry instance65 * @property {function} extractEntryTo An async function, which accepts one parameter.66 * This parameter contains the destination folder path to which this function is going to extract the entry.67 */68/**69 * Get entries for a zip folder70 *71 * @param {string} zipFilePath The full path to the source ZIP file72 * @param {function} onEntry Callback when entry is read.73 * The callback is expected to accept one argument of ZipEntry type.74 * The iteration through the source zip file will bi terminated as soon as75 * the result of this function equals to `false`.76 */77async function readEntries (zipFilePath, onEntry) {78  // Open a zip file and start reading entries79  const zipfile = await open(zipFilePath, {lazyEntries: true});80  const zipReadStreamPromise = new B((resolve, reject) => {81    zipfile.once('end', resolve);82    zipfile.once('error', reject);83    // On each entry, call 'onEntry' and then read the next entry84    zipfile.on('entry', async (entry) => {85      const res = await onEntry({86        entry,87        extractEntryTo: async (destDir) => await _extractEntryTo(zipfile, entry, destDir)88      });89      if (res === false) {90        return zipfile.emit('end');91      }92      zipfile.readEntry();93    });94  });95  zipfile.readEntry();96  // Wait for the entries to finish being iterated through97  return await zipReadStreamPromise;98}99/**100 * Converts contents of local directory to an in-memory .zip buffer101 *102 * @param {string} srcDir The full path to the folder being zipped103 * @returns {Buffer} Zipped content of the source folder as memory buffer104 */105async function toInMemoryZip (srcDir) {106  // Create a writable stream that zip buffers will be streamed to107  const zipBufferArr = [];108  const zipWriteStream = new stream.Writable({109    write: (buffer, encoding, next) => {110      zipBufferArr.push(buffer);111      next();112    },113  });114  const zipWriteStreamPromise = new B((resolve) => {115    // Don't need to do error handling since this writeStream is in-memory and doesn't emit any errors116    zipWriteStream.once('finish', resolve);117  });118  // Zip 'srcDir' and stream it to the above writable stream119  const archive = archiver('zip', {120    zlib: {level: 9}121  });122  const archiveStreamPromise = new B((resolve, reject) => {123    archive.once('finish', resolve);124    archive.once('error', (errStr) => reject(new Error(`Failed to zip directory ${srcDir}: ${errStr}`)));125  });126  archive.directory(srcDir, false);127  archive.pipe(zipWriteStream);128  archive.finalize();129  // Wait for the streams to finish130  await B.all([archiveStreamPromise, zipWriteStreamPromise]);131  // Return the array of zip buffers concatenated into one buffer132  return Buffer.concat(zipBufferArr);133}134/**135 * Verifies whether the given file is a valid ZIP archive136 *137 * @param {string} filePath - Full path to the file138 * @throws {Error} If the file does not exist or is not a valid ZIP archive139 */140async function assertValidZip (filePath) {141  if (!await fs.exists(filePath)) {142    throw new Error(`The file at '${filePath}' does not exist`);143  }144  const {size} = await fs.stat(filePath);145  if (size < 4) {146    throw new Error(`The file at '${filePath}' is too small to be a ZIP archive`);147  }148  const fd = await fs.open(filePath, 'r');149  try {150    const buffer = Buffer.alloc(ZIP_MAGIC.length);151    await fs.read(fd, buffer, 0, ZIP_MAGIC.length, 0);152    const signature = buffer.toString('ascii');153    if (signature !== ZIP_MAGIC) {154      throw new Error(`The file signature '${signature}' of '${filePath}' ` +155        `is not equal to the expected ZIP archive signature '${ZIP_MAGIC}'`);156    }157    return true;158  } finally {159    await fs.close(fd);160  }161}162export { extractAllTo, readEntries, toInMemoryZip, _extractEntryTo, assertValidZip };...

helpers-specs.js

Source:helpers-specs.js

1import { zip, fs, tempDir } from 'appium-support';2import { configureApp, isPackageOrBundle, duplicateKeys, parseCapsArray } from '../../lib/basedriver/helpers';3import chai from 'chai';4import chaiAsPromised from 'chai-as-promised';5import sinon from 'sinon';6chai.use(chaiAsPromised);7const should = chai.should();8describe('helpers', function () {9  describe('#isPackageOrBundle', function () {10    it('should accept packages and bundles', function () {11      isPackageOrBundle('io.appium.testapp').should.be.true;12    });13    it('should not accept non-packages or non-bundles', function () {14      isPackageOrBundle('foo').should.be.false;15      isPackageOrBundle('/path/to/an.app').should.be.false;16      isPackageOrBundle('/path/to/an.apk').should.be.false;17    });18  });19  describe('#duplicateKeys', function () {20    it('should translate key in an object', function () {21      duplicateKeys({'foo': 'hello world'}, 'foo', 'bar').should.eql({'foo': 'hello world', 'bar': 'hello world'});22    });23    it('should translate key in an object within an object', function () {24      duplicateKeys({'key': {'foo': 'hello world'}}, 'foo', 'bar').should.eql({'key': {'foo': 'hello world', 'bar': 'hello world'}});25    });26    it('should translate key in an object with an array', function () {27      duplicateKeys([28        {'key': {'foo': 'hello world'}},29        {'foo': 'HELLO WORLD'}30      ], 'foo', 'bar').should.eql([31        {'key': {'foo': 'hello world', 'bar': 'hello world'}},32        {'foo': 'HELLO WORLD', 'bar': 'HELLO WORLD'}33      ]);34    });35    it('should duplicate both keys', function () {36      duplicateKeys({37        'keyOne': {38          'foo': 'hello world',39        },40        'keyTwo': {41          'bar': 'HELLO WORLD',42        },43      }, 'foo', 'bar').should.eql({44        'keyOne': {45          'foo': 'hello world',46          'bar': 'hello world',47        },48        'keyTwo': {49          'bar': 'HELLO WORLD',50          'foo': 'HELLO WORLD',51        }52      });53    });54    it('should not do anything to primitives', function () {55      [0, 1, -1, true, false, null, undefined, '', 'Hello World'].forEach((item) => {56        should.equal(duplicateKeys(item), item);57      });58    });59    it('should rename keys on big complex objects', function () {60      const input = [61        {'foo': 'bar'},62        {63          hello: {64            world: {65              'foo': 'BAR',66            }67          },68          foo: 'bahr'69        },70        'foo',71        null,72        073      ];74      const expectedOutput = [75        {'foo': 'bar', 'FOO': 'bar'},76        {77          hello: {78            world: {79              'foo': 'BAR',80              'FOO': 'BAR',81            }82          },83          foo: 'bahr',84          FOO: 'bahr'85        },86        'foo',87        null,88        089      ];90      duplicateKeys(input, 'foo', 'FOO').should.deep.equal(expectedOutput);91    });92  });93  describe('#configureApp', function () {94    let sandbox;95    beforeEach(function () {96      sandbox = sinon.createSandbox();97      sandbox.stub(zip, 'extractAllTo').resolves();98      sandbox.stub(zip, 'assertValidZip').resolves();99      sandbox.stub(fs, 'mv').resolves();100      sandbox.stub(fs, 'exists').resolves(true);101      sandbox.stub(fs, 'hash').resolves('0xDEADBEEF');102      sandbox.stub(fs, 'glob').resolves(['/path/to/an.apk']);103      sandbox.stub(fs, 'rimraf').resolves();104      sandbox.stub(fs, 'stat').resolves({105        isDirectory: () => false,106      });107      sandbox.stub(tempDir, 'openDir').resolves('/some/dir');108    });109    afterEach(function () {110      sandbox.restore();111    });112    it('should pass "useSystemUnzip" flag through to appium-support', async function () {113      await configureApp('/path/to/an.apk.zip', '.apk');114      zip.extractAllTo.getCall(0).lastArg.useSystemUnzip.should.be.true;115    });116  });117});118describe('parseCapsArray', function () {119  it('should parse string into array', function () {120    parseCapsArray('/tmp/my/app.zip').should.eql(['/tmp/my/app.zip']);121  });122  it('should parse array as string into array', function () {123    parseCapsArray('["/tmp/my/app.zip"]').should.eql(['/tmp/my/app.zip']);124    parseCapsArray('["/tmp/my/app.zip","/tmp/my/app2.zip"]').should.eql([125      '/tmp/my/app.zip',126      '/tmp/my/app2.zip'127    ]);128  });129  it('should return an array without change', function () {130    parseCapsArray(['a', 'b']).should.eql(['a', 'b']);131  });...

Using AI Code Generation

1const assert = require('assert');2const path = require('path');3const { AppiumBaseDriver } = require('appium-base-driver');4const driver = new AppiumBaseDriver();5const zipPath = path.resolve(__dirname, 'test.zip');6driver.zip.assertValidZip(zipPath);7const assert = require('assert');8const path = require('path');9const { AppiumBaseDriver } = require('appium-base-driver');10const driver = new AppiumBaseDriver();11const zipPath = path.resolve(__dirname, 'test.zip');12const extractToPath = path.resolve(__dirname, 'extracted');13driver.zip.extractAllTo(zipPath, extractToPath);14const assert = require('assert');15const path = require('path');16const { AppiumBaseDriver } = require('appium-base-driver');17const driver = new AppiumBaseDriver();18const zipPath = path.resolve(__dirname, 'test.zip');19const extractToPath = path.resolve(__dirname, 'extracted');20driver.zip.extractFileTo(zipPath, 'test.txt', extractToPath);21const assert = require('assert');22const path = require('path');23const { AppiumBaseDriver } = require('appium-base-driver');24const driver = new AppiumBaseDriver();25const zipPath = path.resolve(__dirname, 'test.zip');26const extractToPath = path.resolve(__dirname, 'extracted');27driver.zip.toInMemoryZip(zipPath);28const assert = require('assert');29const path = require('path');30const { AppiumBaseDriver } = require('appium-base-driver');31const driver = new AppiumBaseDriver();32const folderPath = path.resolve(__dirname, 'test');33const outputPath = path.resolve(__dirname, 'output.zip');34driver.zip.compressFolder(folderPath, outputPath);35const assert = require('assert');36const path = require('path');37const { AppiumBaseDriver } = require('appium-base-driver');38const driver = new AppiumBaseDriver();39const zipPath = path.resolve(__dirname, 'test.zip');40const newFilePath = path.resolve(__dirname

Using AI Code Generation

1const assert = require('assert');2const path = require('path');3const appiumBaseDriver = require('appium-base-driver');4const { zip } = appiumBaseDriver;5const zipPath = path.resolve('test.zip');6const zipContent = 'test';7const zipContentPath = path.resolve('test.txt');8const writeZip = async () => {9  await zip.toInMemoryZip(zipContentPath, zipContent);10  const isValidZip = await zip.assertValidZip(zipPath);11  assert.ok(isValidZip, 'zip is not valid');12};13writeZip();

Using AI Code Generation

1var assert = require('assert');2var zip = require('appium-base-driver').zip;3var validZip = 'test.zip';4var invalidZip = 'test.txt';5zip.assertValidZip(validZip);6zip.assertValidZip(invalidZip);7zip.assertValidZip = function (zipPath) {8  try {9    assert.ok(zip.isValidZip(zipPath));10  } catch (e) {11    logger.errorAndThrow(`The archive at '${zipPath}' is not a valid zip file`);12  }13};14zip.isValidZip = function (zipPath) {15  return new Promise((resolve, reject) => {16    try {17      let zip = new AdmZip(zipPath);18      resolve(zip.getEntries().length > 0);19    } catch (err) {20      reject(err);21    }22  });23};24var assert = require('assert');25var zip = require('appium-base-driver').zip;26var validZip = 'test.zip';27var invalidZip = 'test.txt';28zip.isValidZip(validZip).then((result) => {29  console.log(result);30});31zip.isValidZip(invalidZip).then((result) => {32  console.log(result);33});34zip.isValidZip = function (zipPath) {35  return new Promise((resolve, reject) => {36    try {37      let zip = new AdmZip(zipPath);38      resolve(zip.getEntries().length > 0);39    } catch (err) {40      reject(err);41    }42  });43};44var assert = require('assert');45var zip = require('appium-base-driver').zip;46var zipPath = 'test.zip';47var destPath = 'test';48zip.extractAllTo(zipPath, destPath);

Using AI Code Generation

1var zip = require('appium-support').zip;2var path = require('path');3var zipPath = path.resolve(__dirname, 'test.zip');4zip.assertValidZip(zipPath).then(function (isValid) {5console.log(isValid);6});

Using AI Code Generation

1var path = require('path');2var zip = require('appium-base-driver').zip;3var zipPath = path.resolve(__dirname, 'my.zip');4zip.assertValidZip(zipPath);5var path = require('path');6var zip = require('appium-base-driver').zip;7var zipPath = path.resolve(__dirname, 'my.zip');8zip.toInMemoryZip(zipPath).then(function (base64Zip) {9});10var path = require('path');11var zip = require('appium-base-driver').zip;12var zipPath = path.resolve(__dirname, 'my.zip');13zip.fromInMemoryZip(base64Zip, zipPath).then(function () {14});15var path = require('path');16var zip = require('appium-base-driver').zip;17var zipPath = path.resolve(__dirname, 'my.zip');18zip.toInMemoryZip(zipPath).then(function (base64Zip) {19});20var path = require('path');21var zip = require('appium-base-driver').zip;22var zipPath = path.resolve(__dirname, 'my.zip');23zip.fromInMemoryZip(base64Zip, zipPath).then(function () {24});25var path = require('path');26var zip = require('appium-base-driver').zip;

Using AI Code Generation

1const  AppiumBaseDriver  =  require ( 'appium-base-driver' ) ;2let  zip  =  new  AppiumBaseDriver . helpers . Zip () ;3let  zipFilePath  =  '/Users/username/Downloads/zipfile.zip' ;4zip . assertValidZip ( zipFilePath ) ;5let  invalidZipFilePath  =  '/Users/username/Downloads/invalidzipfile.zip' ;6zip . assertValidZip ( invalidZipFilePath ) ;7const  AppiumBaseDriver  =  require ( 'appium-base-driver' ) ;8let  zip  =  new  AppiumBaseDriver . helpers . Zip () ;9let  zipFilePath  =  '/Users/username/Downloads/zipfile.zip' ;10let  destination  =  '/Users/username/Downloads/zipfile' ;11zip . extractAllTo ( zipFilePath ,  destination ) ;

Using AI Code Generation

1var assertValidZip = require('appium-base-driver').zip.assertValidZip;2var zipFile = 'path/to/zip/file';3assertValidZip(zipFile).then(function () {4  console.log('Zip file is valid');5}).catch(function (err) {6  console.log('Zip file is invalid');7});8assertValidZip(zipFile, {app: true})9assertValidZip(zipFile, {app: true, platform: 'android'})10assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app'})11assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app'})12assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app', appActivity: 'com.example.app.MainActivity'})13assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app', appActivity: 'com.example.app.MainActivity', appWaitActivity: 'com.example.app.SplashActivity'})14assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app', appActivity: 'com.example.app.MainActivity', appWaitActivity: 'com.example.app.SplashActivity', appWaitDuration: 30000})15assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app', appActivity: 'com.example.app.MainActivity', appWaitActivity: 'com.example.app.SplashActivity', appWaitDuration: 30000, appProcess: 'com.example.app'})16assertValidZip(zipFile, {app: true, platform: 'android', bundleId: 'com.example.app', appPackage: 'com.example.app', appActivity: 'com.example.app.MainActivity', appWaitActivity: 'com.example.app.SplashActivity', app

Using AI Code Generation

1var assert = require('assert');2var zip = require('appium-base-driver').zip;3var zipFile = '/Users/username/Desktop/zipFile.zip';4zip.assertValidZip(zipFile, function(err, valid) {5    assert.equal(valid, true);6});

Using AI Code Generation

1const assert = require('assert');2const zip = require('appium-base-driver').zip;3const zipfile = './test.zip';4zip.assertValidZip(zipfile).then(function () {5  console.log('Zip file is valid');6}).catch(function (err) {7  console.log('Zip file is invalid');8});9const assert = require('assert');10const zip = require('appium-base-driver').zip;11const zipfile = './test.zip';12const destination = './test';13zip.unzip(zipfile, destination).then(function () {14  console.log('Zip file unzipped successfully');15}).catch(function (err) {16  console.log('Error unzipping zip file');17});18const assert = require('assert');19const zip = require('appium-base-driver').zip;20const source = './test';21const destination = './test.zip';22zip.zip(source, destination).then(function () {23  console.log('Zip file created successfully');24}).catch(function (err) {25  console.log('Error creating zip file');26});

Using AI Code Generation

1const path = require('path');2const zip = require('appium-base-driver').zip;3const zipFile = process.argv[2];4const dest = process.argv[3];5async function main () {6  if (!zipFile) {7    throw new Error("Please provide a zip file");8  }9  if (!dest) {10    throw new Error("Please provide a destination folder");11  }12  zip.assertValidZip(zipFile);13  await zip.extractAllTo(zipFile, dest);14}15main();16const path = require('path');17const zip = require('appium-base-driver').zip;18const zipFile = process.argv[2];19async function main () {20  if (!zipFile) {21    throw new Error("Please provide a zip file");22  }23  zip.assertValidZip(zipFile);24  await zip.extractAllTo(zipFile);25}26main();27const path = require('path');28const zip = require('appium-base-driver').zip;29const zipFile = process.argv[2];30const dest = process.argv[3];31async function main () {32  if (!zipFile) {33    throw new Error("Please provide a zip file");34  }35  if (!dest) {36    throw new Error("Please provide a destination folder");37  }38  zip.assertValidZip(zipFile);39  await zip.extractAllTo(zipFile, dest);40}41main();42const path = require('path');43const zip = require('appium-base-driver').zip;44const zipFile = process.argv[2];45async function main () {46  if (!zipFile) {47    throw new Error("Please provide a zip file");48  }

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.