Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use fs.mkdirp method in Cypress

Best JavaScript code snippet using cypress

test.js

Source:test.js

1let expect = require('chai').expect;2let Resolver = require('./index');3let MemoryFS = require('memory-fs');4describe('Resolver', () => {5  describe('create', () => {6    it('should throw on invalid filesystem', () => {7      let fs = {};8      expect(() => new Resolver(fs)).to.throw(/filesystem/i);9    });10    it('should throw on null filesystem', () => {11      let fs = null;12      expect(() => new Resolver(fs)).to.throw(/filesystem/i);13    });14    it('should default to node fs', () => {15      new Resolver();16    });17  });18  describe('getMatchesSync', () => {19    it('throw when no filepath is passed', () => {20      let resolver = new Resolver();21      let filepath = null;22      expect(() => resolver.getMatchesSync(filepath)).to.throw(/filepath/i);23    });24    it('should resolve multiple levels', () => {25      // setup26      let fs = new MemoryFS();27      let resolver = new Resolver(fs);28      fs.mkdirpSync('/foo/bar');29      fs.mkdirpSync('/foo[mobile]/bar');30      fs.writeFileSync('/foo/bar/index.js', 'contents');31      fs.writeFileSync('/foo[mobile]/bar/index.js', 'contents');32      fs.writeFileSync('/foo[mobile]/bar/index[ios].js', 'contents');33      //test34      let filepath = '/foo/bar/index.js';35      let matches = resolver.getMatchesSync(filepath);36      expect(matches.raw).to.eql([37        {38          flags: ['mobile', 'ios'],39          value: '/foo[mobile]/bar/index[ios].js'40        },41        {42          flags: ['mobile'],43          value: '/foo[mobile]/bar/index.js'44        },45        {46          flags: [],47          value: '/foo/bar/index.js'48        }49      ]);50    });51    it('should resolve multiple levels invisible dirs', () => {52      // setup53      let fs = new MemoryFS();54      let resolver = new Resolver(fs);55      fs.mkdirpSync('/locales/[en]');56      fs.mkdirpSync('/locales/[US]/[en]');57      fs.mkdirpSync('/locales/[CA]/[en]');58      fs.mkdirpSync('/locales/[CA]/[fr]');59      fs.writeFileSync('/locales/[en]/sample.properties', 'contents');60      fs.writeFileSync('/locales/[US]/[en]/sample.properties', 'contents');61      fs.writeFileSync('/locales/[CA]/[en]/sample.properties', 'contents');62      fs.writeFileSync('/locales/[CA]/[fr]/sample.properties', 'contents');63      //test64      let filepath = '/locales/sample.properties';65      let matches = resolver.getMatchesSync(filepath);66      expect(matches.raw).to.eql([67        {68          flags: ['US', 'en'],69          value: '/locales/[US]/[en]/sample.properties'70        },71        {72          flags: ['CA', 'en'],73          value: '/locales/[CA]/[en]/sample.properties'74        },75        {76          flags: ['CA', 'fr'],77          value: '/locales/[CA]/[fr]/sample.properties'78        },79        {80          flags: ['en'],81          value: '/locales/[en]/sample.properties'82        }83      ]);84    });85    it('should cache for better perf', () => {86      // setup87      let fs = new MemoryFS();88      let resolver = new Resolver(fs);89      fs.mkdirpSync('/foo/bar/baz');90      fs.mkdirpSync('/foo[mobile]/bar/baz');91      fs.mkdirpSync('/foo[desktop]/bar/baz');92      fs.writeFileSync('/foo/bar/baz/index.js', 'contents');93      fs.writeFileSync('/foo[mobile]/bar/baz/index.js', 'contents');94      fs.writeFileSync('/foo[desktop]/bar/baz/index.js', 'contents');95      fs.writeFileSync('/foo[desktop]/bar/baz/index[windows].js', 'contents');96      //test97      let filepath = '/foo/bar/baz/index.js';98      // no cache99      let startNoCache = process.hrtime();100      let matchesNoCache = resolver.getMatchesSync(filepath);101      let elapsedNoCache = process.hrtime(startNoCache);102      expect(matchesNoCache.raw).to.eql([103        {104          flags: ['mobile'],105          value: '/foo[mobile]/bar/baz/index.js'106        },107        {108          flags: ['desktop', 'windows'],109          value: '/foo[desktop]/bar/baz/index[windows].js'110        },111        {112          flags: ['desktop'],113          value: '/foo[desktop]/bar/baz/index.js'114        },115        {116          flags: [],117          value: '/foo/bar/baz/index.js'118        }119      ]);120      // with cache121      let startWithCache = process.hrtime();122      let matchesWithCache = resolver.getMatchesSync(filepath);123      let elapsedWithCache = process.hrtime(startWithCache);124      expect(matchesWithCache.raw).to.eql([125        {126          flags: ['mobile'],127          value: '/foo[mobile]/bar/baz/index.js'128        },129        {130          flags: ['desktop', 'windows'],131          value: '/foo[desktop]/bar/baz/index[windows].js'132        },133        {134          flags: ['desktop'],135          value: '/foo[desktop]/bar/baz/index.js'136        },137        {138          flags: [],139          value: '/foo/bar/baz/index.js'140        }141      ]);142      let noCache = hrToMs(elapsedNoCache);143      let withCache = hrToMs(elapsedWithCache);144      console.log(`noCache: ${noCache.formatted}`);145      console.log(`withCache: ${withCache.formatted}`);146      expect(noCache.value / withCache.value).to.be.above(1);147    });148  });149  describe('resolveSync', () => {150    describe('api errors', () => {151      let resolver = new Resolver();152      it('throw when no filepath is passed', () => {153        let filepath = null;154        let flags = { ios: true };155        expect(() => resolver.resolveSync(filepath, flags)).to.throw(156          /filepath/i157        );158      });159      it('throw when no flags are passed', () => {160        let filepath = '/test/foo/file.text';161        let flags = null;162        expect(() => resolver.resolveSync(filepath, flags)).to.throw(/flags/i);163      });164      it('throw if a relative filepath is passed', () => {165        let filepath = './file.text';166        let flags = { ios: true };167        expect(() => resolver.resolveSync(filepath, flags)).to.throw(168          /filepath/i169        );170      });171    });172    describe('resolution', () => {173      it('should resolve existing directories', () => {174        // setup175        let fs = new MemoryFS();176        let resolver = new Resolver(fs);177        fs.mkdirpSync('/test/foo');178        //test179        let filepath = '/test/foo';180        let flags = { any: true };181        let resolved = resolver.resolveSync(filepath, flags);182        expect(resolved).to.equal('/test/foo');183      });184      it('should resolve existing files', () => {185        // setup186        let fs = new MemoryFS();187        let resolver = new Resolver(fs);188        fs.writeFileSync('/foo.js', 'contents');189        //test190        let filepath = '/foo.js';191        let flags = { any: true };192        let resolved = resolver.resolveSync(filepath, flags);193        expect(resolved).to.equal('/foo.js');194      });195      it('should resolve existing dotfiles', () => {196        // setup197        let fs = new MemoryFS();198        let resolver = new Resolver(fs);199        fs.writeFileSync('/.eslintrc', 'contents');200        //test201        let filepath = '/.eslintrc';202        let flags = { any: true };203        let resolved = resolver.resolveSync(filepath, flags);204        expect(resolved).to.equal('/.eslintrc');205      });206      it('should resolve adapted directories', () => {207        // setup208        let fs = new MemoryFS();209        let resolver = new Resolver(fs);210        fs.mkdirpSync('/test/foo');211        fs.mkdirpSync('/test[flag]/foo');212        //test213        let filepath = '/test/foo';214        let flags = { flag: true };215        let resolved = resolver.resolveSync(filepath, flags);216        expect(resolved).to.equal('/test[flag]/foo');217      });218      it('should resolve adapted dotfiles', () => {219        // setup220        let fs = new MemoryFS();221        let resolver = new Resolver(fs);222        fs.writeFileSync('/.eslintrc', 'contents');223        fs.writeFileSync('/.eslintrc[production]', 'contents');224        //test225        let filepath = '/.eslintrc';226        let flags = { production: true };227        let resolved = resolver.resolveSync(filepath, flags);228        expect(resolved).to.equal('/.eslintrc[production]');229      });230      it('should resolve multiple levels', () => {231        // setup232        let fs = new MemoryFS();233        let resolver = new Resolver(fs);234        fs.mkdirpSync('/foo/bar');235        fs.mkdirpSync('/foo[mobile]/bar');236        fs.writeFileSync('/foo/bar/index.js', 'contents');237        fs.writeFileSync('/foo[mobile]/bar/index.js', 'contents');238        fs.writeFileSync('/foo[mobile]/bar/index[ios].js', 'contents');239        //test240        let filepath = '/foo/bar/index.js';241        let flags = { mobile: true, ios: true };242        let resolved = resolver.resolveSync(filepath, flags);243        expect(resolved).to.equal('/foo[mobile]/bar/index[ios].js');244      });245      it('should not readapt path part', () => {246        // setup247        let fs = new MemoryFS();248        let resolver = new Resolver(fs);249        fs.mkdirpSync('/foo/bar');250        fs.mkdirpSync('/foo[mobile]/bar');251        fs.mkdirpSync('/foo[mobile+ios]/bar');252        fs.writeFileSync('/foo[mobile]/bar/index[ios].js', 'contents');253        fs.writeFileSync('/foo[mobile+ios]/bar/index.js', 'contents');254        //test255        let filepath = '/foo[mobile]/bar/index.js';256        let flags = { mobile: true, ios: true };257        let resolved = resolver.resolveSync(filepath, flags);258        expect(resolved).to.equal('/foo[mobile]/bar/index[ios].js');259      });260      it('should give priority to the most flags', () => {261        // setup262        let fs = new MemoryFS();263        let resolver = new Resolver(fs);264        fs.writeFileSync('/file.js', 'contents');265        fs.writeFileSync('/file[mobile].js', 'contents');266        fs.writeFileSync('/file[mobile+ios].js', 'contents');267        //test268        let filepath = '/file.js';269        let flags = { mobile: true, ios: true };270        let resolved = resolver.resolveSync(filepath, flags);271        expect(resolved).to.equal('/file[mobile+ios].js');272      });273      it('should throw on non existing paths', () => {274        // setup275        let fs = new MemoryFS();276        let resolver = new Resolver(fs);277        //test278        let filepath = '/nope';279        let flags = {};280        expect(() => resolver.resolveSync(filepath, flags)).to.throw(/exist/);281      });282      it('should throw on non-matching paths', () => {283        // setup284        let fs = new MemoryFS();285        let resolver = new Resolver(fs);286        fs.writeFileSync('/file[desktop].js', 'contents');287        fs.writeFileSync('/file[mobile].js', 'contents');288        let filepath = '/file.js';289        let flags = {};290        expect(() => resolver.resolveSync(filepath, flags)).to.throw(/match/);291      });292      it('should give priority to earlier directories', () => {293        // setup294        let fs = new MemoryFS();295        let resolver = new Resolver(fs);296        fs.mkdirpSync('/foo');297        fs.mkdirpSync('/foo[android]');298        fs.writeFileSync('/foo/file[android+another].js', 'contents');299        fs.writeFileSync('/foo[android]/file.js', 'contents');300        //test301        let filepath = '/foo/file.js';302        let flags = { android: true, another: true };303        let resolved = resolver.resolveSync(filepath, flags);304        expect(resolved).to.equal('/foo[android]/file.js');305      });306      it('should cache for better perf', () => {307        // setup308        let fs = new MemoryFS();309        let resolver = new Resolver(fs);310        fs.mkdirpSync('/foo/bar/baz');311        fs.mkdirpSync('/foo[mobile]/bar/baz');312        fs.mkdirpSync('/foo[desktop]/bar/baz');313        fs.writeFileSync('/foo/bar/baz/index.js', 'contents');314        fs.writeFileSync('/foo[mobile]/bar/baz/index.js', 'contents');315        fs.writeFileSync('/foo[desktop]/bar/baz/index.js', 'contents');316        fs.writeFileSync('/foo[desktop]/bar/baz/index[windows].js', 'contents');317        //test318        let filepath = '/foo/bar/baz/index.js';319        let flags = { desktop: true, windows: true };320        // no cache321        let startNoCache = process.hrtime();322        let resolvedNoCache = resolver.resolveSync(filepath, flags);323        let elapsedNoCache = process.hrtime(startNoCache);324        expect(resolvedNoCache).to.equal(325          '/foo[desktop]/bar/baz/index[windows].js'326        );327        // with cache328        let startWithCache = process.hrtime();329        let resolvedWithCache = resolver.resolveSync(filepath, flags);330        let elapsedWithCache = process.hrtime(startWithCache);331        expect(resolvedWithCache).to.equal(332          '/foo[desktop]/bar/baz/index[windows].js'333        );334        let noCache = hrToMs(elapsedNoCache);335        let withCache = hrToMs(elapsedWithCache);336        console.log(`noCache: ${noCache.formatted}`);337        console.log(`withCache: ${withCache.formatted}`);338        expect(noCache.value / withCache.value).to.be.above(1);339      });340      it('should handle multi-extension files', () => {341        // setup342        let fs = new MemoryFS();343        let resolver = new Resolver(fs);344        fs.writeFileSync('/template.marko.js', 'contents');345        fs.writeFileSync('/template[ios].marko.js', 'contents');346        //test347        let filepath = '/template.marko.js';348        let flags = { ios: true };349        let resolved = resolver.resolveSync(filepath, flags);350        expect(resolved).to.equal('/template[ios].marko.js');351      });352      it('should handle names with dots', () => {353        // setup354        let fs = new MemoryFS();355        let resolver = new Resolver(fs);356        fs.writeFileSync('/home.controller.js', 'contents');357        fs.writeFileSync('/home.controller[mobile].js', 'contents');358        //test359        let filepath = '/home.controller.js';360        let flags = { mobile: true };361        let resolved = resolver.resolveSync(filepath, flags);362        expect(resolved).to.equal('/home.controller[mobile].js');363      });364      it.skip('should fallback and try alternate directories', () => {365        // setup366        let fs = new MemoryFS();367        let resolver = new Resolver(fs);368        fs.mkdirpSync('/test/foo');369        fs.mkdirpSync('/test[mobile]/foo/');370        fs.writeFileSync('/test/foo/file[mobile].js', 'contents');371        // test372        let filepath = '/test/foo/file.js';373        let flags = { mobile: true };374        let resolved = resolver.resolveSync(filepath, flags);375        expect(resolved).to.equal('/test/foo/file[mobile].js');376      });377      it('should handle win32 paths', () => {378        // setup379        let fs = new MemoryFS();380        let resolver = new Resolver(fs);381        fs.mkdirpSync('C:\\test\\foo');382        fs.mkdirpSync('C:\\test[mobile]\\foo');383        // test384        let filepath = 'C:\\test\\foo';385        let flags = { mobile: true };386        let resolved = resolver.resolveSync(filepath, flags);387        expect(resolved).to.equal('C:\\test[mobile]\\foo');388      });389    });390  });391  describe('isAdaptiveSync', () => {392    describe('api errors', () => {393      let resolver = new Resolver();394      it('throw when no filepath is passed', () => {395        let filepath = null;396        expect(() => resolver.isAdaptiveSync(filepath)).to.throw(/filepath/i);397      });398      it('throw if a relative filepath is passed', () => {399        let filepath = './file.text';400        expect(() => resolver.isAdaptiveSync(filepath)).to.throw(/filepath/i);401      });402    });403    it('should check non-adaptive paths', () => {404      // setup405      let fs = new MemoryFS();406      let resolver = new Resolver(fs);407      fs.mkdirpSync('/test/foo');408      fs.mkdirpSync('/test/foo/bar');409      // test410      let filepath = '/test/foo/bar';411      let isAdaptive = resolver.isAdaptiveSync(filepath);412      expect(isAdaptive).to.equal(false);413    });414    it('should check adaptive paths', () => {415      // setup416      let fs = new MemoryFS();417      let resolver = new Resolver(fs);418      fs.mkdirpSync('/test/foo/bar');419      fs.mkdirpSync('/test[mobile]/foo/bar');420      // test421      let filepath = '/test/foo/bar';422      let isAdaptive = resolver.isAdaptiveSync(filepath);423      expect(isAdaptive).to.equal(true);424    });425    it('should check already adapted paths', () => {426      // setup427      let fs = new MemoryFS();428      let resolver = new Resolver(fs);429      fs.mkdirpSync('/test/foo/bar');430      fs.mkdirpSync('/test[mobile]/foo/bar');431      // test432      let filepath = '/test[mobile]/foo/bar';433      let isAdaptive = resolver.isAdaptiveSync(filepath);434      expect(isAdaptive).to.equal(false);435    });436    it('should not get confused by files', () => {437      // setup438      let fs = new MemoryFS();439      let resolver = new Resolver(fs);440      fs.mkdirpSync('/test/foo');441      fs.writeFileSync('/test.js', 'contents');442      fs.writeFileSync('/test/foo/index.js', 'contents');443      // test444      let filepath = '/test/foo/index.js';445      let isAdaptive = resolver.isAdaptiveSync(filepath);446      expect(isAdaptive).to.equal(false);447    });448    it('should handle win32 paths', () => {449      // setup450      let fs = new MemoryFS();451      let resolver = new Resolver(fs);452      fs.mkdirpSync('C:\\test\\foo');453      fs.mkdirpSync('C:\\test[mobile]\\foo');454      // test455      let filepath = 'C:\\test\\foo';456      let isAdaptive = resolver.isAdaptiveSync(filepath);457      expect(isAdaptive).to.equal(true);458    });459  });460  describe('clearCache', () => {461    it('clears the cache', () => {462      // setup463      let fs = new MemoryFS();464      let resolver = new Resolver(fs);465      // add a file and resolve466      fs.writeFileSync('/file[before].js', 'Test Contents');467      expect(resolver.resolveSync('/file.js', { before: true })).to.equal(468        '/file[before].js'469      );470      // add a new file, but it can't be found because it's using old cache471      fs.writeFileSync('/file[after].js', 'Test Contents');472      expect(() => resolver.resolveSync('/file.js'), { after: true }).to.throw;473      // clear the cache, now the new file can be found474      resolver.clearCache();475      expect(resolver.resolveSync('/file.js', { after: true })).to.equal(476        '/file[after].js'477      );478    });479  });480});481function hrToMs(hr) {482  let value = hr[0] * 1000 + hr[1] / 1000000;483  return {484    value,485    formatted: value.toFixed(3) + 'ms'486  };...

loadInputFiles.js

Source:loadInputFiles.js

1import assert from 'assert';2import fs from 'fs-extra';3import mock from 'mock-fs';4import path from 'path';5import tmp from 'tmp';6import { utilsFS as utils } from '../../src/utils-fs';7describe('utils-fs.loadInputFiles', () => {8  let tmpInputDir;9  let batch1;10  let batch2;11  beforeEach(() => {12    tmpInputDir = tmp.dirSync({13      unsafeCleanup: true,14    });15    batch1 = path.join(tmpInputDir.name, 'batch_1');16    batch2 = path.join(tmpInputDir.name, 'batch_2');17    fs.mkdirpSync(batch2);18    fs.mkdirpSync(batch1);19  });20  afterEach(() => {21    try {22      tmpInputDir.removeCallback();23    } catch (ignore) {24      // ignore25    }26  });27  it('should only load files in batches', async () => {28    const outputFolder = path.join(tmpInputDir.name, 'downloaded');29    const uploadedFolder = path.join(tmpInputDir.name, 'uploaded');30    fs.mkdirpSync(outputFolder);31    fs.mkdirpSync(uploadedFolder);32    /**33     * Test folder structure:34     * downloaded/downloaded.fastq  should be ignored35     * uploaded/uploaded.fastq      should be ignored36     * batch_1/1.fastq              should be picked up37     * batch_2/2.fastq              should be picked up38     */39    fs.writeFileSync(path.join(batch1, '1.fastq'), '');40    fs.writeFileSync(path.join(batch2, '2.fastq'), '');41    fs.writeFileSync(path.join(batch2, '._2.fastq'), ''); // MC-6941 junk file42    fs.writeFileSync(path.join(outputFolder, 'downloaded.fastq'), '');43    fs.writeFileSync(path.join(uploadedFolder, 'uploaded.fastq'), '');44    const opts = {45      inputFolders: [tmpInputDir.name],46      outputFolder,47      uploadedFolder,48      filetype: '.fastq',49    };50    // stepping through the file system as this is intented to work:51    // first load one batch, then the next, then once all files are gone, return null52    await utils.loadInputFiles(opts).then(async (files) => {53      assert.equal(files.length, 3, 'files1 should find the one valid file');54      assert.equal(files[0].name, '1.fastq', 'should load the folders in alphabetical order');55      fs.unlinkSync(files[0].path);56    });57    await utils.loadInputFiles(opts).then(async (files2) => {58      assert.equal(files2.length, 2, 'files2 should find the one valid file');59      assert.equal(files2[0].name, '2.fastq', 'should load the folders in alphabetical order');60      fs.unlinkSync(files2[0].path);61    });62    fs.unlinkSync(path.join(uploadedFolder, 'uploaded.fastq')); // remove uploaded file63    await utils.loadInputFiles(opts).then((files3) => {64      assert.deepEqual(files3, [], 'should find no files');65    });66  });67  it('MC-7215 should skip undesirable file types', async () => {68    const inputFolder = path.join(tmpInputDir.name, 'data');69    const oneFolder = path.join(inputFolder, 'one');70    const twoFolder = path.join(inputFolder, 'two');71    const passFolder = path.join(inputFolder, 'pass');72    fs.mkdirpSync(inputFolder);73    fs.mkdirpSync(oneFolder);74    fs.mkdirpSync(twoFolder);75    fs.mkdirpSync(passFolder);76    /**77     * Test folder structure:78     * data/1.txt79     * data/fail/1.fast580     * data/fastq_fail/1.fastq81     * data/pass/1.fastq82     */83    fs.writeFileSync(path.join(oneFolder, '1.txt'), '');84    fs.writeFileSync(path.join(twoFolder, '1.fast5'), '');85    fs.writeFileSync(path.join(passFolder, '1.fastq'), '');86    fs.writeFileSync(path.join(inputFolder, '1.fastq'), '');87    const opts = {88      inputFolders: [inputFolder],89      outputFolder: path.join(inputFolder, 'output'),90      filetype: '.fastq',91    };92    await utils.loadInputFiles(opts).then(async (files) => {93      assert.deepEqual(files, [94        {95          name: '1.fastq',96          path: path.join(inputFolder, '1.fastq'),97          relative: '/1.fastq',98          size: 0,99          id: 'FILE_6',100        },101        {102          name: '1.fastq',103          path: path.join(inputFolder, 'pass', '1.fastq'),104          relative: '/pass/1.fastq',105          size: 0,106          id: 'FILE_7',107        },108      ]);109    });110    await fs.remove(inputFolder);111  });112  it('MC-7214 should skip both fail and fastq_fail', async () => {113    const inputFolder = path.join(tmpInputDir.name, 'data');114    const failFolder = path.join(inputFolder, 'fail');115    const fastqFailFolder = path.join(inputFolder, 'fastq_fail');116    const passFolder = path.join(inputFolder, 'pass');117    fs.mkdirpSync(inputFolder);118    fs.mkdirpSync(failFolder);119    fs.mkdirpSync(fastqFailFolder);120    fs.mkdirpSync(passFolder);121    /**122     * Test folder structure:123     * data/1.fastq124     * data/fail/1.fastq125     * data/fastq_fail/1.fastq126     * data/pass/1.fastq127     */128    fs.writeFileSync(path.join(failFolder, '1.fastq'), '');129    fs.writeFileSync(path.join(fastqFailFolder, '1.fastq'), '');130    fs.writeFileSync(path.join(passFolder, '1.fastq'), '');131    fs.writeFileSync(path.join(inputFolder, '1.fastq'), '');132    const opts = {133      inputFolders: [inputFolder],134      outputFolder: path.join(inputFolder, 'output'),135      filetype: '.fastq',136    };137    await utils.loadInputFiles(opts).then(async (files) => {138      assert.deepEqual(files, [139        {140          name: '1.fastq',141          path: path.join(inputFolder, '1.fastq'),142          relative: '/1.fastq',143          size: 0,144          id: 'FILE_8',145        },146        {147          name: '1.fastq',148          path: path.join(inputFolder, 'pass', '1.fastq'),149          relative: '/pass/1.fastq',150          size: 0,151          id: 'FILE_9',152        },153      ]);154    });155    await fs.remove(inputFolder);156  });157  it('MC-6727 should support array of desirable types (and "." addition)', async () => {158    const inputFolder = path.join(tmpInputDir.name, 'data');159    const oneFolder = path.join(inputFolder, 'one');160    const twoFolder = path.join(inputFolder, 'two');161    const passFolder = path.join(inputFolder, 'pass');162    fs.mkdirpSync(inputFolder);163    fs.mkdirpSync(oneFolder);164    fs.mkdirpSync(twoFolder);165    fs.mkdirpSync(passFolder);166    /**167     * Test folder structure:168     * data/1.txt169     * data/fail/1.fast5170     * data/fastq_fail/1.fastq171     * data/pass/1.fastq172     */173    fs.writeFileSync(path.join(oneFolder, '1.txt'), '');174    fs.writeFileSync(path.join(twoFolder, '1.fast5'), '');175    fs.writeFileSync(path.join(passFolder, '1.fq'), '');176    fs.writeFileSync(path.join(passFolder, '1.fq.gz'), '');177    fs.writeFileSync(path.join(inputFolder, '1.fastq'), '');178    fs.writeFileSync(path.join(inputFolder, '1.fastq.gz'), '');179    const opts = {180      inputFolders: [inputFolder],181      outputFolder: path.join(inputFolder, 'output'),182      filetype: ['.fastq', '.fastq.gz', 'fq', 'fq.gz'],183    };184    await utils.loadInputFiles(opts).then(async (files) => {185      assert.deepEqual(files, [186        {187          name: '1.fastq',188          path: path.join(inputFolder, '1.fastq'),189          relative: '/1.fastq',190          size: 0,191          id: 'FILE_10',192        },193        {194          name: '1.fastq.gz',195          path: path.join(inputFolder, '1.fastq.gz'),196          relative: '/1.fastq.gz',197          size: 0,198          id: 'FILE_11',199        },200        {201          name: '1.fq',202          path: path.join(inputFolder, 'pass', '1.fq'),203          relative: '/pass/1.fq',204          size: 0,205          id: 'FILE_12',206        },207        {208          name: '1.fq.gz',209          path: path.join(inputFolder, 'pass', '1.fq.gz'),210          relative: '/pass/1.fq.gz',211          size: 0,212          id: 'FILE_13',213        },214      ]);215    });216    await fs.remove(inputFolder);217  });218  it('MC-6788 should support recursive find through a file', async () => {219    const inputFolder = path.join(tmpInputDir.name, 'data');220    const inputFile = path.join(inputFolder, 'SeqLenti fasta reformat.fasta');221    fs.mkdirpSync(inputFolder);222    fs.writeFileSync(inputFile, '');223    const opts = {224      inputFolders: [inputFile],225      outputFolder: path.join(inputFolder, 'output'),226      filetype: ['.fasta', '.fasta.gz', 'fa', 'fa.gz'],227    };228    await utils.loadInputFiles(opts).then(async (files) => {229      assert.deepEqual(files, [230        {231          name: 'SeqLenti fasta reformat.fasta',232          path: path.join(inputFolder, 'SeqLenti fasta reformat.fasta'),233          relative: '/SeqLenti fasta reformat.fasta',234          size: 0,235          id: 'FILE_14',236        },237      ]);238    });239    await fs.remove(inputFolder);240  });241  describe('MC-7480', () => {242    let root;243    let experiment1Path;244    let experiment2Path;245    let outputFolder;246    beforeEach(() => {247      root = '/data';248      experiment1Path = `${root}/experiment/pass`;249      experiment2Path = `${root}/experiment2/pass`;250      outputFolder = `${root}/output/`;251      mock({252        [experiment1Path]: {253          '1.fastq': 'file content here',254        },255        [experiment2Path]: {256          '1.fastq': 'file content here',257        },258        [outputFolder]: {},259      });260    });261    afterEach(() => {262      mock.restore();263    });264    it('should accept an array of folders to watch', async () => {265      const opts = {266        inputFolders: [experiment1Path, experiment2Path],267        outputFolder,268        filetype: '.fastq',269      };270      await utils.loadInputFiles(opts).then(async (files) => {271        assert.deepEqual(files, [272          {273            name: '1.fastq',274            path: path.join(experiment1Path, '1.fastq'),275            relative: '/1.fastq',276            size: 17,277            id: 'FILE_15',278          },279          {280            name: '1.fastq',281            path: path.join(experiment2Path, '1.fastq'),282            relative: '/1.fastq',283            size: 17,284            id: 'FILE_16',285          },286        ]);287      });288    });289    it('should accept a single file', async () => {290      const opts = {291        inputFolders: [`${experiment1Path}/1.fastq`],292        outputFolder,293        filetype: '.fastq',294      };295      await utils.loadInputFiles(opts).then(async (files) => {296        assert.deepEqual(files, [297          {298            name: '1.fastq',299            path: path.join(experiment1Path, '1.fastq'),300            relative: '/1.fastq',301            size: 17,302            id: 'FILE_17',303          },304        ]);305      });306    });307  });308  describe('MC-7698', () => {309    let root;310    let experiment1Path;311    let outputFolder;312    beforeEach(() => {313      root = '/data';314      experiment1Path = `${root}/reference`;315      mock({316        [experiment1Path]: {317          '1.fasta': 'file content here',318        },319        [outputFolder]: {},320      });321    });322    afterEach(() => {323      mock.restore();324    });325    it('should identify a fasta file', async () => {326      const opts = {327        inputFolders: [`${experiment1Path}/1.fasta`],328        outputFolder,329        filetype: ['fasta'],330      };331      await utils.loadInputFiles(opts).then(async (files) => {332        assert.deepEqual(files, [333          {334            name: '1.fasta',335            path: path.join(experiment1Path, '1.fasta'),336            relative: '/1.fasta',337            size: 17,338            id: 'FILE_18',339          },340        ]);341      });342    });343  });...

tests_3_1_mkdirp.js

Source:tests_3_1_mkdirp.js

...69	});70	describe("async", () => {71		it("should check missing value", () => {72			assert.throws(() => {73				fs.mkdirp();74			}, ReferenceError, "check missing \"directory\" value does not throw an error");75			assert.throws(() => {76				fs.mkdirp(__dirname);77			}, ReferenceError, "check missing \"callback\" value does not throw an error");78		});79		it("should check invalid value", () => {80			assert.throws(() => {81				fs.mkdirp(false, () => {82					// nothing to do here83				});84			}, Error, "check invalid \"directory\" value does not throw an error");85			assert.throws(() => {86				fs.mkdirp(__dirname, false);87			}, Error, "check invalid \"callback\" value does not throw an error");88			assert.throws(() => {89				fs.mkdirp(__dirname, false, () => {90					// nothing to do here91				});92			}, Error, "check invalid \"callback\" value does not throw an error");93		});94		it("should check empty content value", () => {95			assert.throws(() => {96				fs.mkdirp("", () => {97					// nothing to do here98				});99			}, Error, "check empty \"directory\" content value does not throw an error");100		});101		it("should create real existing directory", (done) => {102			const CURRENT_DIRECTORY = __dirname;103			fs.mkdirp(CURRENT_DIRECTORY, (err) => {104				assert.strictEqual(null, err, "\"" + CURRENT_DIRECTORY + "\" cannot be created");105				fs.mkdirp(__dirname, TEST_OPTION, (_err) => {106					assert.strictEqual(null, _err, "\"" + CURRENT_DIRECTORY + "\" cannot be created");107					done();108				});109			});110		});111		it("should create real new directory", (done) => {112			fs.mkdirp(DIR_TESTLVL3, (err) => {113				assert.strictEqual(null, err, "\"" + DIR_TESTLVL3 + "\" cannot be created");114				fs.isDirectory(DIR_TESTLVL3, (_err, exists) => {115					assert.strictEqual(null, _err, "\"" + DIR_TESTLVL3 + "\" cannot be created");116					assert.strictEqual(true, exists, "\"" + DIR_TESTLVL3 + "\" was not created");117					done();118				});119			});120		});121		it("should create real new directory with option", () => {122			return new Promise((resolve, reject) => {123				fs.mkdirp(DIR_TESTLVL3_WITHOPTIONS, TEST_OPTION, (err) => {124					return err ? reject(err) : resolve();125				});126			}).then(() => {127				return fs.isDirectoryProm(DIR_TESTLVL3_WITHOPTIONS).then((exists) => {128					assert.strictEqual(true, exists, "\"" + DIR_TESTLVL3_WITHOPTIONS + "\" was not created");129					return Promise.resolve();130				});131			});132		});133	});134	describe("promise", () => {135		it("should check missing value", (done) => {136			fs.mkdirpProm().then(() => {137				done("check missing value does not generate an error");...

autoConfigure.js

Source:autoConfigure.js

1import assert from 'assert';2import fs from 'fs-extra';3import { merge } from 'lodash';4import path from 'path';5import sinon from 'sinon';6import tmp from 'tmp';7import { EPI2ME_FS as EPI2ME } from '../../src/epi2me-fs';8describe('epi2me.autoConfigure', () => {9  let clock;10  beforeEach(() => {11    clock = sinon.useFakeTimers();12  });13  afterEach(() => {14    clock.restore();15  });16  const clientFactory = (opts) =>17    new EPI2ME(18      merge(19        {20          url: 'https://epi2me-test.local',21          log: {22            debug: sinon.stub(),23            info: sinon.stub(),24            warn: sinon.stub(),25            error: sinon.stub(),26            json: sinon.stub(),27          },28        },29        opts,30      ),31    );32  it('should require inputFolder', async () => {33    const tmpDir = tmp.dirSync();34    const client = clientFactory();35    const autoStartCb = sinon.fake();36    const mkdirp = sinon.stub(fs, 'mkdirp').callsFake((folder, cb) => {37      cb();38    });39    const mkdirpSync = sinon.stub(fs, 'mkdirpSync').callsFake();40    let err;41    try {42      await client.autoConfigure({}, autoStartCb);43    } catch (e) {44      err = e;45    }46    assert(String(err).match(/must set inputFolder/));47    mkdirp.restore();48    mkdirpSync.restore();49    tmpDir.removeCallback();50  });51  it('should require outputFolder', async () => {52    const tmpDir = tmp.dirSync();53    const client = clientFactory({54      inputFolder: path.join(tmpDir.name, 'input'),55    });56    await client.setClassConfigREST({});57    const autoStartCb = sinon.fake();58    const mkdirp = sinon.stub(fs, 'mkdirp').callsFake((folder, cb) => {59      cb();60    });61    const mkdirpSync = sinon.stub(fs, 'mkdirpSync').callsFake();62    let err;63    try {64      await client.autoConfigure({}, autoStartCb);65    } catch (e) {66      err = e;67    }68    assert(String(err).match(/must set outputFolder/));69    mkdirp.restore();70    mkdirpSync.restore();71    tmpDir.removeCallback();72  });73  it('should require inputqueue', async () => {74    const tmpDir = tmp.dirSync();75    const client = clientFactory({76      inputFolders: [path.join(tmpDir.name, 'input')],77      outputFolder: path.join(tmpDir.name, 'output'),78    });79    await client.setClassConfigREST({});80    const autoStartCb = sinon.fake();81    const mkdirp = sinon.stub(fs, 'mkdirp').callsFake((folder, cb) => {82      cb();83    });84    const mkdirpSync = sinon.stub(fs, 'mkdirpSync').callsFake();85    let err;86    try {87      await client.autoConfigure({}, autoStartCb);88    } catch (e) {89      err = e;90    }91    assert(String(err).match(/inputQueueName must be set/));92    mkdirp.restore();93    mkdirpSync.restore();94    tmpDir.removeCallback();95  });96  /*97    it("should require outputqueue", () => {98	const tmpDir    = tmp.dirSync();99	let client      = clientFactory({100	    inputFolder:  path.join(tmpDir.name, "input"),101	    outputFolder: path.join(tmpDir.name, "output"),102	});103	let autoStartCb = sinon.fake();104	let mkdirp      = sinon.stub(fs, "mkdirp").callsFake((folder, cb) => { cb(); });105	let mkdirpSync  = sinon.stub(fs, "mkdirpSync").callsFake();106	let createWriteStream = sinon.stub(fs, "createWriteStream").callsFake();107	let stub1 = sinon.stub(client.REST, "workflow_instance").callsFake();108	let stub2 = sinon.stub(client, "session").callsFake();109	assert.throws(() => {110	    client.autoConfigure({111		    inputqueue:  "input_queue",112	    }, autoStartCb);113	}, Error);114	stub1.restore();115	stub2.restore();116	mkdirp.restore();117	mkdirpSync.restore();118	createWriteStream.restore();119	tmpDir.removeCallback();120    });121    it("should autoconfigure", () => {122	const tmpDir    = tmp.dirSync();123	let client      = clientFactory({124	    inputFolder:  path.join(tmpDir.name, "input"),125	    outputFolder: path.join(tmpDir.name, "output"),126	});127	let autoStartCb = sinon.fake();128	let mkdirp      = sinon.stub(fs, "mkdirp").callsFake((folder, cb) => { cb(); });129	let mkdirpSync  = sinon.stub(fs, "mkdirpSync").callsFake();130	let createWriteStream = sinon.stub(fs, "createWriteStream").callsFake();131	let stub1 = sinon.stub(client.REST, "workflow_instance").callsFake();132	let stub2 = sinon.stub(client, "loadUploadFiles").callsFake();133	let stub3 = sinon.stub(client, "session").callsFake((cb) => { cb(); });134	assert.doesNotThrow(() => {135	    client.autoConfigure({136		inputqueue:  "input_queue",137		outputqueue: "output_queue",138		id_user:    1234,139		id_workflow_instance: 56789,140	    }, autoStartCb);141	}, Error, "path cannot join nulls");142	stub1.restore();143	stub2.restore();144	stub3.restore();145	mkdirp.restore();146	mkdirpSync.restore();147	createWriteStream.restore();148	tmpDir.removeCallback();149    });150*/...

mkdirp.js

Source:mkdirp.js

1import { module, test } from "qunit";2import sinon from "sinon";3import mkdirpInjector from "inject-loader!utils/node/fs/mkdirp";4module( "utils/node/fs/mkdirp", function( hooks ) {5	/** @typedef {Object} TestContextUtilsNodeFsMkdirp */6	hooks.beforeEach( /** @this {TestContextUtilsNodeFsMkdirp} */ function() {7		this.mkdirStub = sinon.stub().callsFake( path => Promise.resolve( path ) );8		/** @type {Function} subject */9		this.subject = mkdirpInjector({10			fs: {11				promises: {12					mkdir: this.mkdirStub13				}14			}15		})[ "default" ];16	});17	test( "Error", async function( assert ) {18		/** @this {TestContextUtilsNodeFsMkdirp} */19		const err = new Error( "foo" );20		this.mkdirStub.rejects( err );21		await assert.rejects(22			this.subject( "/foo/bar" ),23			err,24			"Rejects with error"25		);26		assert.propEqual(27			this.mkdirStub.args,28			[[ "/foo/bar", { recursive: true } ]],29			"Sets the recursive option to true"30		);31	});32	test( "Simple parameters", async function( assert ) {33		/** @this {TestContextUtilsNodeFsMkdirp} */34		assert.strictEqual(35			await this.subject( "/foo/bar" ),36			"/foo/bar",37			"Returns the created path"38		);39		assert.propEqual(40			this.mkdirStub.args,41			[[ "/foo/bar", { recursive: true } ]],42			"Sets the recursive option to true"43		);44	});45	test( "Mode option", async function( assert ) {46		/** @this {TestContextUtilsNodeFsMkdirp} */47		assert.strictEqual(48			await this.subject( "/foo/bar", { mode: 0o111 } ),49			"/foo/bar",50			"Returns the created path"51		);52		assert.propEqual(53			this.mkdirStub.args,54			[[ "/foo/bar", { recursive: true, mode: 0o111 } ]],55			"Sets the recursive option to true and keeps the mode option"56		);57	});58	test( "Invalid options", async function( assert ) {59		/** @this {TestContextUtilsNodeFsMkdirp} */60		const options = { recursive: false, foo: "bar" };61		assert.strictEqual(62			await this.subject( "/foo/bar", options ),63			"/foo/bar",64			"Returns the created path"65		);66		assert.propEqual(67			this.mkdirStub.args,68			[[ "/foo/bar", { recursive: true, foo: "bar" } ]],69			"Always sets the recursive option to true and keeps other options"70		);71		assert.propEqual(72			options,73			{ recursive: false, foo: "bar" },74			"Doesn't alter the input options properties"75		);76	});...

mkdirp.mjs

Source:mkdirp.mjs

...25    info: 'invalid argument type errors with E_ARG_TYPE',26  },27  {28    fn: async () => {29      await fs.mkdirp(tmpDir)30      return await fs.exists(tmpDir)31    },32    before,33    expect: true,34    info: 'fs.mkdirp can create deep directories',35  },36  {37    fn: async () => await fs.mkdirp(process.cwd()),38    expect: true,39    info: 'fs.mkdirp returns true if directory exists',40  },...

fs.extra.js

Source:fs.extra.js

1(function () {2  "use strict";3  var oldFs = require('fs')4    , extraFs = require('fs-extra')5    , fs = {}6    ;7  Object.keys(extraFs).forEach(function (key) {8    fs[key] = extraFs[key];9  });10  Object.keys(oldFs).forEach(function (key) {11    fs[key] = oldFs[key];12  });13  fs.copy = require('./fs.copy.js');14  fs.copyRecursive = require('./fs.copy-recursive.js');15  fs.move = require('./fs.move.js');16  fs.mkdirp = require('mkdirp');17  fs.mkdirpSync = fs.mkdirp.sync;18  // Alias19  fs.mkdirRecursive = fs.mkdirp;20  fs.mkdirRecursiveSync = fs.mkdirp.sync;21  fs.remove = extraFs.remove;22  fs.removeSync = extraFs.removeSync;23  // Alias24  fs.rmrf = extraFs.remove;25  fs.rmrfSync = extraFs.removeSync;26  fs.rmRecursive = extraFs.rmrf;27  fs.rmRecursiveSync = extraFs.rmrfSync;28  fs.walk = require('walk').walk;29  module.exports = fs;...

structure.js

Source:structure.js

1const fs = require('fs-extra')2// criaÃ§Ã£o de estrutura de pastas do projeto3function struct ({ creditor, wallet }) {4  createFolders(creditor, wallet)5}6function createFolders (creditor, wallet = '') {7  fs.mkdirpSync(`../../${creditor}/${wallet}/`)8  fs.mkdirpSync(`../../${creditor}/${wallet}/`)9  fs.mkdirpSync(`../../${creditor}/${wallet}/`)10  fs.mkdirpSync(`../../${creditor}/${wallet}/`)11  fs.mkdirpSync(`../../${creditor}/${wallet}/`)12  fs.mkdirpSync(`../../${creditor}/${wallet}/`)13  fs.mkdirpSync(`../../${creditor}/${wallet}/`)14  fs.mkdirpSync(`../../${creditor}/${wallet}/`)15}...

Using AI Code Generation

1describe('My first test', () => {2  it('Does not do much!', () => {3    expect(true).to.equal(true)4  })5})6const fs = require('fs')7Cypress.Commands.add('mkdirp', (dir) => {8  return new Promise((resolve, reject) => {9    fs.mkdir(dir, { recursive: true }, (err) => {10      if (err) {11        reject(err)12      } else {13        resolve(dir)14      }15    })16  })17})18describe('My first test', () => {19  it('Does not do much!', () => {20    cy.mkdirp('cypress/screenshots')21    expect(true).to.equal(true)22  })23})24{25}

Using AI Code Generation

1describe('Cypress fs.mkdirp', () => {2    it('should create a directory', () => {3        cy.fs.mkdirp('cypress/fixtures/abc')4    })5})6describe('Cypress fs.writeFile', () => {7    it('should write a file', () => {8        cy.fs.writeFile('cypress/fixtures/abc/xyz.txt', 'some text')9    })10})11describe('Cypress fs.readFile', () => {12    it('should read a file', () => {13        cy.fs.readFile('cypress/fixtures/abc/xyz.txt', 'utf8')14        .then((text) => {15            expect(text).to.equal('some text')16        })17    })18})19describe('Cypress fs.remove', () => {20    it('should remove a file', () => {21        cy.fs.remove('cypress/fixtures/abc/xyz.txt')22    })23})24describe('Cypress fs.rmdir', () => {25    it('should remove a directory', () => {26        cy.fs.rmdir('cypress/fixtures/abc')27    })28})29describe('Cypress fs.stat', () => {30    it('should return file stats', () => {31        cy.fs.stat('cypress/fixtures/abc')32        .then((stats) => {33            expect(stats.isDirectory()).to.be.true34        })35    })36})37describe('Cypress fs.readdir', () => {38    it('should return directory contents', () => {39        cy.fs.readdir('cypress/fixtures')40        .then((files) => {41            expect(files).to.deep.equal(['abc'])42        })43    })44})45describe('Cypress fs.copy', () => {46    it('should copy a file', () => {47        cy.fs.copy('cypress/fixtures/abc', 'cypress/fixtures/xyz')48    })49})50describe('Cypress fs

Using AI Code Generation

1describe('test', () => {2  it('test', () => {3    cy.writeFile('cypress/integration/test/test.txt', 'test')4  })5})6describe('test', () => {7  it('test', () => {8    cy.writeFile('cypress/integration/test/test.txt', 'test')9  })10})11Recommended Posts: Cypress | cy.readFile() command12Cypress | cy.writeFile() command13Cypress | cy.wrap() command14Cypress | cy.visit() command15Cypress | cy.clearLocalStorage() command16Cypress | cy.clearCookies() command17Cypress | cy.clearLocalStorage() command18Cypress | cy.contains() command19Cypress | cy.exec() command20Cypress | cy.go() command21Cypress | cy.hash() command22Cypress | cy.location() command23Cypress | cy.reload() command24Cypress | cy.screenshot() command25Cypress | cy.scrollTo() command26Cypress | cy.title() command27Cypress | cy.viewport() command28Cypress | cy.wait() command29Cypress | cy.wrap() command30Cypress | cy.get() command31Cypress | cy.getCookie() command32Cypress | cy.getCookies() command33Cypress | cy.getIframeBody() command34Cypress | cy.getIframeHead() command

Cypress Tutorial

Cypress is a renowned Javascript-based open-source, easy-to-use end-to-end testing framework primarily used for testing web applications. Cypress is a relatively new player in the automation testing space and has been gaining much traction lately, as evidenced by the number of Forks (2.7K) and Stars (42.1K) for the project. LambdaTest’s Cypress Tutorial covers step-by-step guides that will help you learn from the basics till you run automation tests on LambdaTest.

Chapters:

What is Cypress? -
Why Cypress? - Learn why Cypress might be a good choice for testing your web applications.
Features of Cypress Testing - Learn about features that make Cypress a powerful and flexible tool for testing web applications.
Cypress Drawbacks - Although Cypress has many strengths, it has a few limitations that you should be aware of.
Cypress Architecture - Learn more about Cypress architecture and how it is designed to be run directly in the browser, i.e., it does not have any additional servers.
Browsers Supported by Cypress - Cypress is built on top of the Electron browser, supporting all modern web browsers. Learn browsers that support Cypress.
Selenium vs Cypress: A Detailed Comparison - Compare and explore some key differences in terms of their design and features.
Cypress Learning: Best Practices - Take a deep dive into some of the best practices you should use to avoid anti-patterns in your automation tests.
How To Run Cypress Tests on LambdaTest? - Set up a LambdaTest account, and now you are all set to learn how to run Cypress tests.

Certification

You can elevate your expertise with end-to-end testing using the Cypress automation framework and stay one step ahead in your career by earning a Cypress certification. Check out our Cypress 101 Certification.