From 6f808b9c093b75e18428bfdb2cf5ab33cce0d483 Mon Sep 17 00:00:00 2001
From: segayuu <segayuu@gmail.com>
Date: Sat, 14 Jul 2018 06:15:00 +0900
Subject: [PATCH] simple typed test: hexo-fs (#27246)

---
 types/hexo-fs/hexo-fs-tests.ts | 1049 +++-----------------------------
 1 file changed, 99 insertions(+), 950 deletions(-)

diff --git a/types/hexo-fs/hexo-fs-tests.ts b/types/hexo-fs/hexo-fs-tests.ts
index 7bdd8918fb..d678e91f34 100644
--- a/types/hexo-fs/hexo-fs-tests.ts
+++ b/types/hexo-fs/hexo-fs-tests.ts
@@ -1,995 +1,144 @@
+import 'mocha';
 import fs = require('hexo-fs');
-import { join, dirname } from 'path';
 import chai = require('chai');
 import Promise = require('bluebird');
-
-// Stub mocha functions
-const {describe, it, before, after, beforeEach, afterEach} = null as any as {
-    [s: string]: ((s: string, cb: (done: any) => void) => void) & ((cb: (done: any) => void) => void) & {only: any, skip: any};
-};
+import { FSWatcher } from 'chokidar';
 
 const should = chai.should();
 
-function createDummyFolder(path: string) {
-    return Promise.all([
-        // Normal files in a hidden folder
-        fs.writeFile(join(path, '.hidden', 'a.txt'), 'a'),
-        fs.writeFile(join(path, '.hidden', 'b.js'), 'b'),
-        // Normal folder in a hidden folder
-        fs.writeFile(join(path, '.hidden', 'c', 'd'), 'd'),
-        // Top-class files
-        fs.writeFile(join(path, 'e.txt'), 'e'),
-        fs.writeFile(join(path, 'f.js'), 'f'),
-        // A hidden file
-        fs.writeFile(join(path, '.g'), 'g'),
-        // Files in a normal folder
-        fs.writeFile(join(path, 'folder', 'h.txt'), 'h'),
-        fs.writeFile(join(path, 'folder', 'i.js'), 'i'),
-        // A hidden files in a normal folder
-        fs.writeFile(join(path, 'folder', '.j'), 'j')
-    ]);
-}
+let string = '';
+let strings = [string];
+let bool = false;
+let boolPromise: Promise<boolean>;
+let stringPromise: Promise<string>;
+let stringsPromise: Promise<string[]>;
+let stringOrStrings: string|string[];
+let stringOrStringsPromise: Promise<string|string[]>;
+let watcherPromise: Promise<FSWatcher>;
+let writeStream: fs.WriteStream;
+let writeStreamPromise: Promise<fs.WriteStream>;
 
-const tmpDir = join(__dirname, 'fs_tmp');
+boolPromise = fs.exists(string);
 
-before(() => fs.mkdirs(tmpDir));
-
-after(done => {
-    fs.rmdir(tmpDir);
-    done();
+fs.exists(string, exist => {
+    bool = exist;
 });
 
-it('exists()', () => {
-    return fs.exists(tmpDir).then(exist => {
-        exist.should.be.true;
-    });
+// $ExpectType Bluebird<void>
+fs.mkdirs(string);
+
+fs.mkdirs(string, err => {
+    should.not.exist(err);
 });
 
-it('exists() - callback', callback => {
-    fs.exists(tmpDir, (exist) => {
-        exist.should.be.true;
-        callback();
-    });
+// $ExpectType void
+fs.mkdirsSync(string);
+
+// $ExpectType Bluebird<void>
+fs.writeFile(string, 'foo');
+
+fs.writeFile(string, 'foo', err => {
+    should.not.exist(err);
 });
 
-it('mkdirs()', () => {
-    const target = join(tmpDir, 'a', 'b', 'c');
+// $ExpectType void
+fs.writeFileSync(string, 'foo');
 
-    return fs.mkdirs(target).then(() => {
-        return fs.exists(target);
-    }).then(exist => {
-        exist.should.be.true;
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+// $ExpectType Bluebird<void>
+fs.appendFile(string, 'foo');
+
+fs.appendFile(string, 'bar', err => {
+    should.not.exist(err);
 });
 
-it('mkdirs() - callback', callback => {
-    const target = join(tmpDir, 'a', 'b', 'c');
+// $ExpectType void
+fs.appendFileSync(string, 'bar');
 
-    fs.mkdirs(target, err => {
-        should.not.exist(err);
+// $ExpectType Bluebird<void>
+fs.copyFile(string, string);
 
-        fs.exists(target, exist => {
-            exist.should.be.true;
-            fs.rmdir(join(tmpDir, 'a'), callback);
-        });
-    });
+fs.copyFile(string, string, err => {
+    should.not.exist(err);
 });
 
-it('mkdirsSync()', () => {
-    const target = join(tmpDir, 'a', 'b', 'c');
+stringsPromise = fs.copyDir(string, string);
 
-    fs.mkdirsSync(target);
-
-    return fs.exists(target).then(exist => {
-        exist.should.be.true;
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+fs.copyDir(string, string, (err, files) => {
+    should.not.exist(err);
+    strings = files!;
 });
 
-it('writeFile()', () => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
+stringsPromise = fs.copyDir(string, string, { ignoreHidden: false });
+stringsPromise = fs.copyDir(string, string, { ignorePattern: /\.js/ });
 
-    return fs.writeFile(target, body).then(() => {
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql(body);
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+stringsPromise = fs.listDir(string);
+
+fs.listDir(string, (err, files) => {
+    should.not.exist(err);
+    strings = files!;
 });
 
-it('writeFile() - callback', callback => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
+stringsPromise = fs.listDir(string, { ignoreHidden: false });
+stringsPromise = fs.listDir(string, { ignorePattern: /\.js/ });
 
-    fs.writeFile(target, body, err => {
-        should.not.exist(err);
+stringOrStrings = fs.listDirSync(string);
+stringOrStrings = fs.listDirSync(string, { ignoreHidden: false });
+stringOrStrings = fs.listDirSync(string, { ignorePattern: /\.js/ });
 
-        fs.readFile(target, (_, content) => {
-            content!.should.eql(body);
-            fs.rmdir(join(tmpDir, 'a'), callback);
-        });
-    });
+stringPromise = fs.readFile(string);
+
+fs.readFile(string, (err, content) => {
+    should.not.exist(err);
+    string = content!;
 });
 
-it('writeFileSync()', () => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
+string = fs.readFileSync(string);
 
-    fs.writeFileSync(target, body);
+// $ExpectType Bluebird<void>
+fs.unlink(string);
 
-    return fs.readFile(target).then(content => {
-        content.should.eql(body);
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+stringOrStringsPromise = fs.emptyDir(string);
+
+fs.emptyDir(string, (err, files) => {
+    should.not.exist(err);
+    stringOrStrings = files!;
 });
 
-it('appendFile()', () => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
-    const body2 = 'bar';
+stringOrStringsPromise = fs.emptyDir(string, { ignoreHidden: false });
+stringOrStringsPromise = fs.emptyDir(string, { ignorePattern: /\.js/ });
+stringOrStringsPromise = fs.emptyDir(string, { exclude: strings });
 
-    return fs.writeFile(target, body).then(() => {
-        return fs.appendFile(target, body2);
-    }).then(() => {
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql(body + body2);
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+stringOrStrings = fs.emptyDirSync(string);
+stringOrStrings = fs.emptyDirSync(string, { ignoreHidden: false });
+stringOrStrings = fs.emptyDirSync(string, { ignorePattern: /\.js/ });
+stringOrStrings = fs.emptyDirSync(string, { exclude: strings });
+
+// $ExpectType Bluebird<void>
+fs.rmdir(string);
+
+fs.rmdir(string, err => {
+    should.not.exist(err);
 });
 
-it('appendFile() - callback', callback => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
-    const body2 = 'bar';
+// $ExpectType void
+fs.rmdirSync(string);
 
-    fs.writeFile(target, body, () => {
-        fs.appendFile(target, body2, err => {
-            should.not.exist(err);
+watcherPromise = fs.watch(string);
 
-            fs.readFile(target, (_, content) => {
-                content!.should.eql(body + body2);
-                fs.rmdir(join(tmpDir, 'a'), callback);
-            });
-        });
-    });
+stringPromise = fs.ensurePath(string);
+
+fs.ensurePath(string, (err, path) => {
+    should.not.exist(err);
+    string = path!;
 });
 
-it('appendFileSync()', () => {
-    const target = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
-    const body2 = 'bar';
+string = fs.ensurePathSync(string);
 
-    return fs.writeFile(target, body).then(() => {
-        fs.appendFileSync(target, body2);
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql(body + body2);
-        return fs.rmdir(join(tmpDir, 'a'));
-    });
+writeStreamPromise = fs.ensureWriteStream(string);
+
+fs.ensureWriteStream(string, (err, stream) => {
+    should.not.exist(err);
+    writeStream = stream!;
 });
 
-it('copyFile()', () => {
-    const src = join(tmpDir, 'test.txt');
-    const dest = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
-
-    return fs.writeFile(src, body).then(() => {
-        return fs.copyFile(src, dest);
-    }).then(() => {
-        return fs.readFile(dest);
-    }).then(content => {
-        content.should.eql(body);
-
-        return Promise.all([
-            fs.unlink(src),
-            fs.rmdir(join(tmpDir, 'a'))
-        ]);
-    });
-});
-
-it('copyFile() - callback', callback => {
-    const src = join(tmpDir, 'test.txt');
-    const dest = join(tmpDir, 'a', 'b', 'test.txt');
-    const body = 'foo';
-
-    fs.writeFile(src, body, err => {
-        if (err) return callback(err);
-
-        fs.copyFile(src, dest, err => {
-            if (err) return callback(err);
-
-            fs.readFile(dest, (err, content) => {
-                if (err)
-                    return callback(err);
-                content!.should.eql(body);
-
-                Promise.all([
-                    fs.unlink(src),
-                    fs.rmdir(join(tmpDir, 'a'))
-                ]).asCallback(callback);
-            });
-        });
-    });
-});
-
-it('copyDir()', () => {
-    const src = join(tmpDir, 'a');
-    const dest = join(tmpDir, 'b');
-
-    return createDummyFolder(src).then(() => {
-        return fs.copyDir(src, dest);
-    }).then(files => {
-        files.should.have.members([
-            'e.txt',
-            'f.js',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js')
-        ]);
-
-        return Promise.all([
-            fs.readFile(join(dest, 'e.txt')),
-            fs.readFile(join(dest, 'f.js')),
-            fs.readFile(join(dest, 'folder', 'h.txt')),
-            fs.readFile(join(dest, 'folder', 'i.js'))
-        ]);
-    }).then(result => {
-        result.should.eql(['e', 'f', 'h', 'i']);
-    }).then(() => {
-        return Promise.all([
-            fs.rmdir(src),
-            fs.rmdir(dest)
-        ]);
-    });
-});
-
-it('copyDir() - callback', callback => {
-    const src = join(tmpDir, 'a');
-    const dest = join(tmpDir, 'b');
-
-    createDummyFolder(src).then(() => {
-        fs.copyDir(src, dest, (err, files) => {
-            should.not.exist(err);
-            files!.should.have.members([
-                'e.txt',
-                'f.js',
-                join('folder', 'h.txt'),
-                join('folder', 'i.js')
-            ]);
-
-            Promise.all([
-                fs.readFile(join(dest, 'e.txt')),
-                fs.readFile(join(dest, 'f.js')),
-                fs.readFile(join(dest, 'folder', 'h.txt')),
-                fs.readFile(join(dest, 'folder', 'i.js'))
-            ]).then(result => {
-                result.should.eql(['e', 'f', 'h', 'i']);
-            }).then(() => {
-                return Promise.all([
-                    fs.rmdir(src),
-                    fs.rmdir(dest)
-                ]);
-            }).asCallback(callback);
-        });
-    });
-});
-
-it('copyDir() - ignoreHidden off', () => {
-    const src = join(tmpDir, 'a');
-    const dest = join(tmpDir, 'b');
-
-    return createDummyFolder(src).then(() => {
-        return fs.copyDir(src, dest, { ignoreHidden: false });
-    }).then(files => {
-        files.should.have.members([
-            join('.hidden', 'a.txt'),
-            join('.hidden', 'b.js'),
-            join('.hidden', 'c', 'd'),
-            'e.txt',
-            'f.js',
-            '.g',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js'),
-            join('folder', '.j')
-        ]);
-
-        return Promise.all([
-            fs.readFile(join(dest, '.hidden', 'a.txt')),
-            fs.readFile(join(dest, '.hidden', 'b.js')),
-            fs.readFile(join(dest, '.hidden', 'c', 'd')),
-            fs.readFile(join(dest, 'e.txt')),
-            fs.readFile(join(dest, 'f.js')),
-            fs.readFile(join(dest, '.g')),
-            fs.readFile(join(dest, 'folder', 'h.txt')),
-            fs.readFile(join(dest, 'folder', 'i.js')),
-            fs.readFile(join(dest, 'folder', '.j'))
-        ]);
-    }).then(result => {
-        result.should.eql(['a', 'b', 'd', 'e', 'f', 'g', 'h', 'i', 'j']);
-    }).then(() => {
-        return Promise.all([
-            fs.rmdir(src),
-            fs.rmdir(dest)
-        ]);
-    });
-});
-
-it('copyDir() - ignorePattern', () => {
-    const src = join(tmpDir, 'a');
-    const dest = join(tmpDir, 'b');
-
-    return createDummyFolder(src).then(() => {
-        return fs.copyDir(src, dest, { ignorePattern: /\.js/ });
-    }).then(files => {
-        files.should.have.members(['e.txt', join('folder', 'h.txt')]);
-
-        return Promise.all([
-            fs.readFile(join(dest, 'e.txt')),
-            fs.readFile(join(dest, 'folder', 'h.txt'))
-        ]);
-    }).then(result => {
-        result.should.eql(['e', 'h']);
-    }).then(() => {
-        return Promise.all([
-            fs.rmdir(src),
-            fs.rmdir(dest)
-        ]);
-    });
-});
-
-it('listDir()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.listDir(target);
-    }).then(files => {
-        files.should.have.members([
-            'e.txt',
-            'f.js',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js')
-        ]);
-
-        return fs.rmdir(target);
-    });
-});
-
-it('listDir() - callback', callback => {
-    const target = join(tmpDir, 'test');
-
-    createDummyFolder(target).then(() => {
-        fs.listDir(target, (err, files) => {
-            if (err) return callback(err);
-
-            files!.should.have.members([
-                'e.txt',
-                'f.js',
-                join('folder', 'h.txt'),
-                join('folder', 'i.js')
-            ]);
-
-            fs.rmdir(target, callback);
-        });
-    });
-});
-
-it('listDir() - ignoreHidden off', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.listDir(target, { ignoreHidden: false });
-    }).then(files => {
-        files.should.have.members([
-            join('.hidden', 'a.txt'),
-            join('.hidden', 'b.js'),
-            join('.hidden', 'c', 'd'),
-            'e.txt',
-            'f.js',
-            '.g',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js'),
-            join('folder', '.j')
-        ]);
-
-        return fs.rmdir(target);
-    });
-});
-
-it('listDir() - ignorePattern', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.listDir(target, { ignorePattern: /\.js/ });
-    }).then(files => {
-        files.should.have.members(['e.txt', join('folder', 'h.txt')]);
-        return fs.rmdir(target);
-    });
-});
-
-it('listDirSync()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        const files = fs.listDirSync(target);
-        files.should.have.members([
-            'e.txt',
-            'f.js',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js')
-        ]);
-
-        return fs.rmdir(target);
-    });
-});
-
-it('listDirSync() - ignoreHidden off', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        const files = fs.listDirSync(target, { ignoreHidden: false });
-        files.should.have.members([
-            join('.hidden', 'a.txt'),
-            join('.hidden', 'b.js'),
-            join('.hidden', 'c', 'd'),
-            'e.txt',
-            'f.js',
-            '.g',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js'),
-            join('folder', '.j')
-        ]);
-
-        return fs.rmdir(target);
-    });
-});
-
-it('listDirSync() - ignorePattern', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        const files = fs.listDirSync(target, { ignorePattern: /\.js/ });
-        files.should.have.members(['e.txt', join('folder', 'h.txt')]);
-        return fs.rmdir(target);
-    });
-});
-
-it('readFile()', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = 'test';
-
-    return fs.writeFile(target, body).then(() => {
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql(body);
-        return fs.unlink(target);
-    });
-});
-
-it('readFile() - callback', callback => {
-    const target = join(tmpDir, 'test.txt');
-    const body = 'test';
-
-    fs.writeFile(target, body, err => {
-        if (err) return callback(err);
-
-        fs.readFile(target, (err, content) => {
-            if (err) return callback(err);
-
-            content!.should.eql(body);
-
-            fs.unlink(target).asCallback(callback);
-        });
-    });
-});
-
-it('readFile() - escape BOM', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = '\ufefffoo';
-
-    return fs.writeFile(target, body).then(() => {
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql('foo');
-        return fs.unlink(target);
-    });
-});
-
-it('readFile() - escape Windows line ending', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = 'foo\r\nbar';
-
-    return fs.writeFile(target, body).then(() => {
-        return fs.readFile(target);
-    }).then(content => {
-        content.should.eql('foo\nbar');
-        return fs.unlink(target);
-    });
-});
-
-it('readFileSync()', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = 'test';
-
-    return fs.writeFile(target, body).then(() => {
-        fs.readFileSync(target).should.eql(body);
-        return fs.unlink(target);
-    });
-});
-
-it('readFileSync() - escape BOM', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = '\ufefffoo';
-
-    return fs.writeFile(target, body).then(() => {
-        fs.readFileSync(target).should.eql('foo');
-        return fs.unlink(target);
-    });
-});
-
-it('readFileSync() - escape Windows line ending', () => {
-    const target = join(tmpDir, 'test.txt');
-    const body = 'foo\r\nbar';
-
-    return fs.writeFile(target, body).then(() => {
-        fs.readFileSync(target).should.eql('foo\nbar');
-        return fs.unlink(target);
-    });
-});
-
-it('unlink()', () => {
-    const target = join(tmpDir, 'test-unlink');
-
-    return fs.writeFile(target, '').then(() => {
-        return fs.exists(target);
-    }).then(exist => {
-        exist.should.eql(true);
-        return fs.unlink(target);
-    }).then(() => {
-        return fs.exists(target);
-    }).then(exist => {
-        exist.should.eql(false);
-    });
-});
-
-it('emptyDir()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.emptyDir(target);
-    }).then<Array<[string, boolean]>>(files => {
-        files.should.have.members([
-            'e.txt',
-            'f.js',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js')
-        ]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), false],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDir() - callback', callback => {
-    const target = join(tmpDir, 'test');
-
-    createDummyFolder(target).then(() => {
-        fs.emptyDir(target, (err, files) => {
-            if (err) return callback(err);
-
-            files!.should.have.members([
-                'e.txt',
-                'f.js',
-                join('folder', 'h.txt'),
-                join('folder', 'i.js')
-            ]);
-
-            Promise.map([
-                [join(target, '.hidden', 'a.txt'), true],
-                [join(target, '.hidden', 'b.js'), true],
-                [join(target, '.hidden', 'c', 'd'), true],
-                [join(target, 'e.txt'), false],
-                [join(target, 'f.js'), false],
-                [join(target, '.g'), true],
-                [join(target, 'folder', 'h.txt'), false],
-                [join(target, 'folder', 'i.js'), false],
-                [join(target, 'folder', '.j'), true]
-            ], (data: any) => {
-                return fs.exists(data[0]).then(exist => {
-                    exist.should.eql(data[1]);
-                });
-            }).then(() => {
-                return fs.rmdir(target);
-            }).asCallback(callback);
-        });
-    });
-});
-
-it('emptyDir() - ignoreHidden off', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.emptyDir(target, { ignoreHidden: false });
-    }).then<Array<[string, boolean]>>(files => {
-        files.should.have.members([
-            join('.hidden', 'a.txt'),
-            join('.hidden', 'b.js'),
-            join('.hidden', 'c', 'd'),
-            'e.txt',
-            'f.js',
-            '.g',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js'),
-            join('folder', '.j')
-        ]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), false],
-            [join(target, '.hidden', 'b.js'), false],
-            [join(target, '.hidden', 'c', 'd'), false],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), false],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), false],
-            [join(target, 'folder', '.j'), false]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDir() - ignorePattern', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.emptyDir(target, { ignorePattern: /\.js/ });
-    }).then<Array<[string, boolean]>>(files => {
-        files.should.have.members(['e.txt', join('folder', 'h.txt')]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), true],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), true],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDir() - exclude', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.emptyDir(target, { exclude: ['e.txt', join('folder', 'i.js')] });
-    }).then<Array<[string, boolean]>>(files => {
-        files.should.have.members(['f.js', join('folder', 'h.txt')]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), true],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), true],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDirSync()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then<Array<[string, boolean]>>(() => {
-        const files = fs.emptyDirSync(target);
-        files.should.have.members([
-            'e.txt',
-            'f.js',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js')
-        ]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), false],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDirSync() - ignoreHidden off', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then<Array<[string, boolean]>>(() => {
-        const files = fs.emptyDirSync(target, { ignoreHidden: false });
-        files.should.have.members([
-            join('.hidden', 'a.txt'),
-            join('.hidden', 'b.js'),
-            join('.hidden', 'c', 'd'),
-            'e.txt',
-            'f.js',
-            '.g',
-            join('folder', 'h.txt'),
-            join('folder', 'i.js'),
-            join('folder', '.j')
-        ]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), false],
-            [join(target, '.hidden', 'b.js'), false],
-            [join(target, '.hidden', 'c', 'd'), false],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), false],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), false],
-            [join(target, 'folder', '.j'), false]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDirSync() - ignorePattern', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then<Array<[string, boolean]>>(() => {
-        const files = fs.emptyDirSync(target, { ignorePattern: /\.js/ });
-        files.should.have.members(['e.txt', join('folder', 'h.txt')]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), false],
-            [join(target, 'f.js'), true],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), true],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('emptyDirSync() - exclude', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then<Array<[string, boolean]>>(() => {
-        const files = fs.emptyDirSync(target, { exclude: ['e.txt', join('folder', 'i.js')] });
-        files.should.have.members(['f.js', join('folder', 'h.txt')]);
-
-        return [
-            [join(target, '.hidden', 'a.txt'), true],
-            [join(target, '.hidden', 'b.js'), true],
-            [join(target, '.hidden', 'c', 'd'), true],
-            [join(target, 'e.txt'), true],
-            [join(target, 'f.js'), false],
-            [join(target, '.g'), true],
-            [join(target, 'folder', 'h.txt'), false],
-            [join(target, 'folder', 'i.js'), true],
-            [join(target, 'folder', '.j'), true]
-        ];
-    }).map(data => {
-        return fs.exists(data[0]).then(exist => {
-            exist.should.eql(data[1]);
-        });
-    }).then(() => {
-        return fs.rmdir(target);
-    });
-});
-
-it('rmdir()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        return fs.rmdir(target);
-    }).then(() => {
-        return fs.exists(target);
-    }).then(exist => {
-        exist.should.be.false;
-    });
-});
-
-it('rmdir() - callback', callback => {
-    const target = join(tmpDir, 'test');
-
-    createDummyFolder(target).then(() => {
-        fs.rmdir(target, err => {
-            should.not.exist(err);
-
-            fs.exists(target, exist => {
-                exist.should.be.false;
-                callback();
-            });
-        });
-    });
-});
-
-it('rmdirSync()', () => {
-    const target = join(tmpDir, 'test');
-
-    return createDummyFolder(target).then(() => {
-        fs.rmdirSync(target);
-        return fs.exists(target);
-    }).then(exist => {
-        exist.should.be.false;
-    });
-});
-
-import { FSWatcher } from 'chokidar';
-
-it('watch()', () => {
-    let watcher: FSWatcher;
-
-    return fs.watch(tmpDir).then(watcher_ => {
-        watcher = watcher_;
-
-        return new Promise((resolve, reject) => {
-            const path = join(tmpDir, 'test.txt');
-
-            watcher.on('add', (path_) => {
-                path_.should.eql(path);
-                resolve();
-            });
-
-            fs.writeFile(path, 'test').catch(reject);
-        });
-    }).finally(() => {
-        if (watcher) watcher.close();
-    });
-});
-
-it('ensurePath() - file exists', () => {
-    const target = join(tmpDir, 'test');
-
-    return Promise.all([
-        fs.writeFile(join(target, 'foo.txt'), ''),
-        fs.writeFile(join(target, 'foo-1.txt'), ''),
-        fs.writeFile(join(target, 'foo-2.md'), ''),
-        fs.writeFile(join(target, 'bar.txt'), '')
-    ]).then(() => {
-        return fs.ensurePath(join(target, 'foo.txt'));
-    }).then(path => {
-        path.should.eql(join(target, 'foo-2.txt'));
-        return fs.rmdir(target);
-    });
-});
-
-it('ensurePath() - file not exist', () => {
-    const target = join(tmpDir, 'foo.txt');
-
-    return fs.ensurePath(target).then(path => {
-        path.should.eql(target);
-    });
-});
-
-it('ensurePath() - callback', callback => {
-    const target = join(tmpDir, 'test');
-
-    Promise.all([
-        fs.writeFile(join(target, 'foo.txt'), ''),
-        fs.writeFile(join(target, 'foo-1.txt'), ''),
-        fs.writeFile(join(target, 'foo-2.md'), ''),
-        fs.writeFile(join(target, 'bar.txt'), '')
-    ]).then(() => {
-        fs.ensurePath(join(target, 'foo.txt'), (err, path) => {
-            should.not.exist(err);
-            path!.should.eql(join(target, 'foo-2.txt'));
-            fs.rmdir(target, callback);
-        });
-    });
-});
-
-it('ensurePathSync() - file exists', () => {
-    const target = join(tmpDir, 'test');
-
-    return Promise.all([
-        fs.writeFile(join(target, 'foo.txt'), ''),
-        fs.writeFile(join(target, 'foo-1.txt'), ''),
-        fs.writeFile(join(target, 'foo-2.md'), ''),
-        fs.writeFile(join(target, 'bar.txt'), '')
-    ]).then(() => {
-        const path = fs.ensurePathSync(join(target, 'foo.txt'));
-        path.should.eql(join(target, 'foo-2.txt'));
-
-        return fs.rmdir(target);
-    });
-});
-
-it('ensurePathSync() - file not exist', () => {
-    const target = join(tmpDir, 'foo.txt');
-    const path = fs.ensurePathSync(target);
-
-    path.should.eql(target);
-});
-
-it('ensureWriteStream()', () => {
-    const target = join(tmpDir, 'foo', 'bar.txt');
-
-    return fs.ensureWriteStream(target).then(stream => {
-        stream.path.should.eql(target);
-        stream.on('finish', () => {
-            return fs.unlink(target);
-        });
-    });
-});
-
-it('ensureWriteStream() - callback', callback => {
-    const target = join(tmpDir, 'foo', 'bar.txt');
-
-    fs.ensureWriteStream(target, (err, stream) => {
-        should.not.exist(err);
-        stream!.path.should.eql(target);
-        callback();
-    });
-});
-
-it('ensureWriteStreamSync()', () => {
-    const target = join(tmpDir, 'foo', 'bar.txt');
-    const stream = fs.ensureWriteStreamSync(target);
-
-    stream.path.should.eql(target);
-    stream.on('finish', () => {
-        return fs.rmdir(dirname(target));
-    });
-});
+writeStream = fs.ensureWriteStreamSync(string);