841 lines
No EOL
25 KiB
JavaScript
841 lines
No EOL
25 KiB
JavaScript
import path from 'path'
|
|
import assert from '../lib/assert.mjs'
|
|
import t from '../lib/eltro.mjs'
|
|
import { Builder, Counter } from './watch/builder.mjs'
|
|
import watch from '../lib/watch/index.mjs'
|
|
import * as is from '../lib/watch/is.mjs'
|
|
import hasNativeRecursive from '../lib/watch/has-native-recursive.mjs'
|
|
|
|
const builder = new Builder()
|
|
let watcher
|
|
|
|
function htTimeToMs(end) {
|
|
return end[0] * 1000 + Math.round(end[1] / 1000000)
|
|
}
|
|
|
|
t.before(function() {
|
|
return builder.init()
|
|
})
|
|
|
|
t.afterEach(function(done) {
|
|
if (watcher && !watcher.isClosed()) {
|
|
watcher.on('close', done)
|
|
watcher.close()
|
|
} else {
|
|
done()
|
|
}
|
|
})
|
|
|
|
t.after(function() {
|
|
if (builder) {
|
|
builder.cleanup()
|
|
}
|
|
})
|
|
|
|
function wait(fn, timeout) {
|
|
try {
|
|
fn()
|
|
} catch (error) {
|
|
timeout -= 30
|
|
if (timeout >= 0) {
|
|
setTimeout(function() {
|
|
wait(fn, timeout)
|
|
}, 30)
|
|
} else {
|
|
throw error
|
|
}
|
|
}
|
|
}
|
|
|
|
t.only().describe('watcher', function() {
|
|
t.describe('process events', function() {
|
|
t.test('should emit `close` event', function(done) {
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
watcher = watch(fpath, function() {})
|
|
watcher.on('close', done)
|
|
watcher.close()
|
|
})
|
|
|
|
t.test('should emit `ready` event when watching a file', function(done) {
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
watcher = watch(fpath)
|
|
watcher.on('ready', done)
|
|
})
|
|
|
|
t.test('should emit `ready` event when watching a directory recursively', function(done) {
|
|
var dir = builder.getPath('home')
|
|
watcher = watch(dir, { recursive: true })
|
|
watcher.on('ready', done)
|
|
})
|
|
|
|
t.test('should emit `ready` properly in a composed watcher', function(done) {
|
|
var dir1 = builder.getPath('home/a')
|
|
var dir2 = builder.getPath('home/b')
|
|
var file = builder.getPath('home/b/file1')
|
|
watcher = watch([dir1, dir2, file], { recursive: true })
|
|
watcher.on('ready', done)
|
|
})
|
|
})
|
|
|
|
t.describe('watch for files', function() {
|
|
t.test('should watch a single file and keep watching', function(done) {
|
|
var counter = new Counter(done, 3)
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
watcher = watch(fpath, { delay: 0 }, function(evt, name) {
|
|
assert.strictEqual(fpath, name)
|
|
counter.count()
|
|
})
|
|
watcher.on('ready', function() {
|
|
counter.waitForCount(builder.modify(file))
|
|
.then(() => counter.waitForCount(builder.modify(file)))
|
|
.then(() => counter.waitForCount(builder.modify(file)))
|
|
})
|
|
})
|
|
|
|
t.test('should watch files inside a directory', function(done) {
|
|
var fpath = builder.getPath('home/a')
|
|
var set = new Set()
|
|
set.add(builder.getPath('home/a/file1'))
|
|
set.add(builder.getPath('home/a/file2'))
|
|
|
|
Promise.all([
|
|
builder.newFile('home/a/file1'),
|
|
builder.newFile('home/a/file2'),
|
|
]).then(() => {
|
|
watcher = watch(fpath, { delay: 0 }, function(evt, name) {
|
|
set.delete(name)
|
|
if (!set.size) {
|
|
done()
|
|
}
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
Promise.all([
|
|
builder.modify('home/a/file1'),
|
|
builder.modify('home/a/file2'),
|
|
]).then()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should debounce multiple triggers', function(done) {
|
|
var counter = new Counter()
|
|
var file = 'home/a/file2'
|
|
var fpath = builder.getPath(file)
|
|
|
|
var start = process.hrtime()
|
|
var middle = start
|
|
var end = start
|
|
|
|
watcher = watch(fpath, { delay: 100 }, function(evt, name) {
|
|
if (fpath === name) counter.count()
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
builder.modify(file)
|
|
.then(() => builder.modify(file))
|
|
.then(() => builder.modify(file))
|
|
.then(() => {
|
|
middle = htTimeToMs(process.hrtime(start))
|
|
return counter.waitForCount()
|
|
})
|
|
.then(() => {
|
|
assert.strictEqual(counter.counter, 1)
|
|
end = htTimeToMs(process.hrtime(start))
|
|
|
|
assert.ok(end - middle > 50)
|
|
assert.ok(end >= 100)
|
|
done()
|
|
})
|
|
.catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should listen to new created files', function(done) {
|
|
var home = builder.getPath('home')
|
|
var counter = new Counter()
|
|
var newfile1 = 'home/a/newfile' + builder.randomName()
|
|
var newfile2 = 'home/a/newfile' + builder.randomName()
|
|
var set = new Set([
|
|
builder.getPath(newfile1),
|
|
builder.getPath(newfile2),
|
|
])
|
|
var changes = []
|
|
var extra = []
|
|
watcher = watch(home, { delay: 0, recursive: true }, function(evt, name) {
|
|
if (set.has(name)) {
|
|
changes.push(name)
|
|
counter.count()
|
|
} else {
|
|
extra.push(name)
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
counter.waitForCount(builder.newFile(newfile1))
|
|
.then(() => counter.waitForCount(builder.newFile(newfile2)))
|
|
.then(() => {
|
|
assert.deepStrictEqual(changes, [...set.values()])
|
|
// assert.deepStrictEqual(extra, [])
|
|
done()
|
|
})
|
|
.catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should error when parent gets deleted before calling fs.watch', function(done) {
|
|
var fpath = builder.getPath('home/a/file1')
|
|
builder.newFile('home/a/file1')
|
|
.then(() => {
|
|
watcher = watch(fpath, Object.defineProperty({}, 'test', {
|
|
enumerable: true,
|
|
get: function() {
|
|
builder.removeSync('home/a')
|
|
return 'test'
|
|
}
|
|
}))
|
|
watcher.on('error', function() {
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('watch for directories', function() {
|
|
t.test('should watch directories inside a directory', function(done) {
|
|
var home = builder.getPath('home')
|
|
var dir = builder.getPath('home/c')
|
|
|
|
builder.createDirectory('home/c').then(() => {
|
|
watcher = watch(home, { delay: 0, recursive: true }, function(evt, name) {
|
|
if (name === dir && evt === 'remove') {
|
|
done()
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.remove('home/c').catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should watch new created directories', function(done) {
|
|
var home = builder.getPath('home')
|
|
|
|
builder.remove('home/new').then(() => {
|
|
watcher = watch(home, { delay: 0, recursive: true }, function(evt, name) {
|
|
if (name === builder.getPath('home/new/file1')) {
|
|
done()
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.newFile('home/new/file1')
|
|
.then(() => builder.modify('home/new/file1'))
|
|
.catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should not watch new created directories which are being skipped in the filter', function(done) {
|
|
var counter = new Counter(done, 1)
|
|
var home = builder.getPath('home')
|
|
|
|
var options = {
|
|
delay: 0,
|
|
recursive: true,
|
|
filter: function(filePath, SKIP_FLAG) {
|
|
if (/ignored/.test(filePath)) {
|
|
counter.count()
|
|
return SKIP_FLAG
|
|
}
|
|
return false
|
|
}
|
|
}
|
|
|
|
builder.remove('home/ignored/file').then(() => {
|
|
watcher = watch(home, options, function(evt, name) {
|
|
assert.fail("should not watch new created directories which are being skipped in the filter event detect: " + name)
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
builder.newFile('home/ignored/file')
|
|
.catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should keep watching after removal of sub directory', function(done) {
|
|
var counter = new Counter(done, 3)
|
|
var home = builder.getPath('home')
|
|
var file1 = builder.getPath('home/e/file1')
|
|
var file2 = builder.getPath('home/e/file2')
|
|
var dir = builder.getPath('home/e/sub')
|
|
var set = new Set()
|
|
|
|
Promise.all([
|
|
builder.newFile('home/e/sub/testfile'),
|
|
builder.newFile('home/e/file1'),
|
|
builder.newFile('home/e/file2'),
|
|
]).then(() => {
|
|
|
|
watcher = watch(home, { delay: 0, recursive: true }, function(evt, name) {
|
|
if (name === dir || name === file1 || name === file2) {
|
|
if (!set.has(name)) {
|
|
set.add(name)
|
|
counter.count()
|
|
}
|
|
}
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
builder.remove('home/e/sub')
|
|
builder.modify('home/e/file1')
|
|
builder.modify('home/e/file2')
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should watch new directories without delay', function(done) {
|
|
var counter = new Counter(done, 1)
|
|
var home = builder.getPath('home')
|
|
|
|
builder.remove('home/new').then(() => {
|
|
watcher = watch(home, { delay: 200, recursive: true }, function(evt, name) {
|
|
if (name === builder.getPath('home/new/file1')) {
|
|
counter.count()
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.newFile('home/new/file1')
|
|
.then(() => builder.modify('home/new/file1'))
|
|
.then(() => builder.modify('home/new/file1'))
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should error when directory gets deleted before calling fs.watch', function(done) {
|
|
var dir = 'home/c'
|
|
var fpath = builder.getPath(dir)
|
|
|
|
builder.createDirectory(dir).then(() => {
|
|
watcher = watch(fpath, Object.defineProperty({}, 'test', {
|
|
enumerable: true,
|
|
get: function() {
|
|
builder.removeSync(dir)
|
|
return 'test'
|
|
}
|
|
}))
|
|
watcher.on('error', function() {
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('file events', function() {
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
|
|
t.beforeEach(function() {
|
|
return builder.newFile(file)
|
|
})
|
|
|
|
t.test('should identify `remove` event', function(done) {
|
|
watcher = watch(fpath, { delay: 0 }, function(evt, name) {
|
|
if (evt === 'remove' && name === fpath) {
|
|
done()
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.remove(file).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should identify `remove` event on directory', function(done) {
|
|
var dir = 'home/a'
|
|
var home = builder.getPath('home')
|
|
var fpath = builder.getPath(dir)
|
|
|
|
watcher = watch(home, { delay: 0 }, function(evt, name) {
|
|
if (evt === 'remove' && name === fpath) done()
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.remove(dir).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should be able to handle many events on deleting', function(done) {
|
|
var dir = 'home/a'
|
|
var fpath = builder.getPath(dir)
|
|
|
|
builder.newRandomFiles(dir, 100).then(names => {
|
|
var counter = new Counter(done, names.length)
|
|
|
|
watcher = watch(fpath, { delay: 10 }, function(evt, name) {
|
|
if (evt === 'remove') counter.count()
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
Promise.all(names.map(x => builder.remove(path.join(dir, x)))).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should identify `update` event', function(done) {
|
|
var file = 'home/b/file1'
|
|
var fpath = builder.getPath(file)
|
|
builder.newFile(file).then(() => {
|
|
watcher = watch(fpath, { delay: 0 }, function(evt, name) {
|
|
if (evt === 'update' && name === fpath) done()
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.modify(file).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should report `update` on new files', function(done) {
|
|
var dir = builder.getPath('home/a')
|
|
var file = 'home/a/newfile_' + builder.randomName()
|
|
var fpath = builder.getPath(file)
|
|
|
|
watcher = watch(dir, { delay: 0 }, function(evt, name) {
|
|
if (evt === 'update' && name === fpath) done()
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.newFile(file).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('options', function() {
|
|
t.describe('recursive', function() {
|
|
t.test('should watch recursively with `recursive: true` option', function(done) {
|
|
var dir = builder.getPath('home')
|
|
var file = builder.getPath('home/bb/file1')
|
|
watcher = watch(dir, { delay: 0, recursive: true }, function(evt, name) {
|
|
if (file === name) {
|
|
done()
|
|
}
|
|
})
|
|
watcher.on('ready', function() {
|
|
builder.modify('home/bb/file1').catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('encoding', function() {
|
|
let options = {
|
|
delay: 0,
|
|
encoding: 'unknown'
|
|
};
|
|
|
|
var fdir = builder.getPath('home/a')
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
|
|
t.before(() => {
|
|
return builder.newFile(file)
|
|
})
|
|
|
|
t.test('should throw on invalid encoding', function(done) {
|
|
options.encoding = 'unknown'
|
|
try {
|
|
watcher = watch(fdir, options)
|
|
} catch (e) {
|
|
done()
|
|
}
|
|
})
|
|
|
|
t.test('should accept an encoding string', function(done) {
|
|
options.encoding = 'utf8'
|
|
watcher = watch(fdir, options, done.finish(function(evt, name) {
|
|
assert.strictEqual(name.toString(), fpath)
|
|
}))
|
|
watcher.on('ready', function() {
|
|
builder.modify(file).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should support buffer encoding', function(done) {
|
|
options.encoding = 'buffer'
|
|
watcher = watch(fdir, options, done.finish(function(evt, name) {
|
|
assert.ok(Buffer.isBuffer(name), 'not a Buffer')
|
|
assert.strictEqual(name.toString(), fpath)
|
|
}))
|
|
|
|
watcher.on('ready', function() {
|
|
builder.modify(file).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should support base64 encoding', function(done) {
|
|
options.encoding = 'base64'
|
|
watcher = watch(fdir, options, done.finish(function(evt, name) {
|
|
assert.strictEqual(
|
|
name,
|
|
Buffer.from(fpath).toString('base64'),
|
|
'wrong base64 encoding'
|
|
)
|
|
}))
|
|
watcher.on('ready', function() {
|
|
builder.modify(file).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should support hex encoding', function(done) {
|
|
options.encoding = 'hex'
|
|
watcher = watch(fdir, options, done.finish(function(evt, name) {
|
|
assert.strictEqual(
|
|
name,
|
|
Buffer.from(fpath).toString('hex'),
|
|
'wrong hex encoding'
|
|
)
|
|
}))
|
|
watcher.on('ready', function() {
|
|
builder.modify(file).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('filter', function() {
|
|
t.test('should only watch filtered directories', function(done) {
|
|
var matchRegularDir = false
|
|
var matchIgnoredDir = false
|
|
var counter = new Counter(done.finish(function() {
|
|
assert(matchRegularDir, 'watch failed to detect regular file')
|
|
assert(!matchIgnoredDir, 'fail to ignore path `deep_node_modules`')
|
|
}), 1, true)
|
|
|
|
var options = {
|
|
delay: 0,
|
|
recursive: true,
|
|
filter: function(name) {
|
|
return !/deep_node_modules/.test(name)
|
|
}
|
|
}
|
|
|
|
watcher = watch(builder.getPath('home'), options, function(evt, name) {
|
|
if (/deep_node_modules/.test(name)) {
|
|
matchIgnoredDir = true
|
|
} else {
|
|
matchRegularDir = true
|
|
}
|
|
counter.count()
|
|
})
|
|
watcher.on('ready', function() {
|
|
counter.startCounting()
|
|
builder.modify('home/deep_node_modules/ma/file1')
|
|
.then(() => builder.modify('home/b/file1'))
|
|
.catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should only report filtered files', function(done) {
|
|
var dir = builder.getPath('home')
|
|
var file1 = 'home/bb/file1'
|
|
var file2 = 'home/bb/file2'
|
|
|
|
|
|
var counter = new Counter(done.finish(function() {
|
|
assert.strictEqual(matchIgnoredFile, false, 'home/bb/file1 should be ignored')
|
|
}), 1, true)
|
|
|
|
var options = {
|
|
delay: 0,
|
|
recursive: true,
|
|
filter: function(name) {
|
|
return /file2/.test(name)
|
|
}
|
|
}
|
|
|
|
var times = 0
|
|
var matchIgnoredFile = false
|
|
watcher = watch(dir, options, function(evt, name) {
|
|
if (name === builder.getPath(file1)) {
|
|
matchIgnoredFile = true
|
|
}
|
|
counter.count()
|
|
})
|
|
watcher.on('ready', function() {
|
|
counter.startCounting()
|
|
|
|
builder.modify(file2)
|
|
.then(() => builder.modify(file1))
|
|
.catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should be able to filter directly with regexp', function(done) {
|
|
var dir = builder.getPath('home')
|
|
var file1 = 'home/bb/file1'
|
|
var file2 = 'home/bb/file2'
|
|
|
|
|
|
var counter = new Counter(done.finish(function() {
|
|
assert.strictEqual(matchIgnoredFile, false, 'home/bb/file1 should be ignored')
|
|
}), 1, true)
|
|
|
|
var options = {
|
|
delay: 0,
|
|
recursive: true,
|
|
filter: /file2/
|
|
}
|
|
|
|
var times = 0
|
|
var matchIgnoredFile = false
|
|
watcher = watch(dir, options, function(evt, name) {
|
|
if (name === builder.getPath(file1)) {
|
|
matchIgnoredFile = true
|
|
}
|
|
counter.count()
|
|
})
|
|
watcher.on('ready', function() {
|
|
counter.startCounting()
|
|
|
|
builder.modify(file2)
|
|
.then(() => builder.modify(file1))
|
|
.catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should be able to skip subdirectories with `skip` flag', function(done) {
|
|
var home = builder.getPath('home')
|
|
var options = {
|
|
delay: 0,
|
|
recursive: true,
|
|
filter: function(name, skip) {
|
|
if (/\/deep_node_modules/.test(name)) return skip
|
|
}
|
|
}
|
|
watcher = watch(home, options)
|
|
|
|
watcher.getWatchedPaths(function(paths) {
|
|
hasNativeRecursive(function(supportRecursive) {
|
|
var watched = supportRecursive
|
|
// The skip flag has no effect to the platforms which support recursive option,
|
|
// so the home directory is the only one that's in the watching list.
|
|
? [home]
|
|
// The deep_node_modules and all its subdirectories should not be watched
|
|
// with skip flag specified in the filter.
|
|
: builder.getAllDirectories().filter(function(name) {
|
|
return !/\/deep_node_modules/.test(name)
|
|
})
|
|
|
|
assert.deepStrictEqual(
|
|
watched.sort(), paths.sort()
|
|
)
|
|
|
|
done()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('parameters', function() {
|
|
t.test('should throw error on non-existed file', function(done) {
|
|
var somedir = builder.getPath('home/somedir')
|
|
watcher = watch(somedir)
|
|
watcher.on('error', done.finish(function(err) {
|
|
assert.match(err.message, /not exist/)
|
|
}))
|
|
})
|
|
|
|
t.test('should accept filename as Buffer', function(done) {
|
|
var fpath = builder.getPath('home/a/file1')
|
|
watcher = watch(Buffer.from(fpath), { delay: 0 }, done.finish(function(evt, name) {
|
|
assert.strictEqual(name, fpath)
|
|
}))
|
|
watcher.on('ready', function() {
|
|
builder.modify('home/a/file1').catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should compose array of files or directories', function(done) {
|
|
var counter = new Counter(done, 2)
|
|
var file1 = 'home/a/file1'
|
|
var file2 = 'home/a/file2'
|
|
var fpaths = [
|
|
builder.getPath(file1),
|
|
builder.getPath(file2)
|
|
]
|
|
var set = new Set(fpaths)
|
|
|
|
Promise.all([
|
|
builder.newFile(file1),
|
|
builder.newFile(file2),
|
|
]).then(function() {
|
|
watcher = watch(fpaths, { delay: 0 }, function(evt, name) {
|
|
if (set.has(name)) {
|
|
set.delete(name)
|
|
counter.count()
|
|
}
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
Promise.all([
|
|
builder.modify(file1),
|
|
builder.modify(file2),
|
|
]).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('should filter duplicate events for composed watcher', function(done) {
|
|
var counter = new Counter(done, 2)
|
|
var home = 'home'
|
|
var dir = 'home/a'
|
|
var file1 = 'home/a/file1'
|
|
var file2 = 'home/a/file2'
|
|
var fpaths = [
|
|
builder.getPath(home),
|
|
builder.getPath(dir),
|
|
builder.getPath(file1),
|
|
builder.getPath(file2)
|
|
]
|
|
|
|
console.log()
|
|
var changes = []
|
|
watcher = watch(fpaths, { delay: 100, recursive: true }, function(evt, name) {
|
|
changes.push(name)
|
|
counter.count()
|
|
})
|
|
|
|
watcher.on('ready', function() {
|
|
new Promise(res => {
|
|
counter.updateRes(res)
|
|
|
|
builder.modify(file1)
|
|
.then(() => builder.modify(file2))
|
|
})
|
|
.then(() => builder.delay(50))
|
|
.then(() => {
|
|
assert.deepStrictEqual(
|
|
changes,
|
|
[fpaths[2], fpaths[3]]
|
|
)
|
|
done()
|
|
}).catch(done)
|
|
})
|
|
})
|
|
})
|
|
|
|
t.describe('watcher object', function() {
|
|
t.test('should using watcher object to watch', function(done) {
|
|
var dir = builder.getPath('home/a')
|
|
var file = 'home/a/file1'
|
|
var fpath = builder.getPath(file)
|
|
|
|
watcher = watch(dir, { delay: 0 })
|
|
|
|
watcher.on('change', done.finish(function(evt, name) {
|
|
assert.strictEqual(evt, 'update')
|
|
assert.strictEqual(name, fpath)
|
|
}))
|
|
|
|
watcher.on('ready', done.wrap(function() {
|
|
builder.modify(file)
|
|
}))
|
|
})
|
|
|
|
t.describe('close()', function() {
|
|
t.test('should close a watcher using .close()', function(done) {
|
|
var dir = builder.getPath('home/a')
|
|
var file = 'home/a/file1'
|
|
var times = 0
|
|
watcher = watch(dir, { delay: 0 })
|
|
watcher.on('change', function(evt, name) {
|
|
times++
|
|
})
|
|
watcher.on('ready', function() {
|
|
watcher.close()
|
|
|
|
builder.modify(file)
|
|
.then(() => builder.delay(50))
|
|
.then(() => builder.modify(file))
|
|
.then(() => builder.delay(50))
|
|
.then(() => {
|
|
assert(watcher.isClosed(), 'watcher should be closed')
|
|
assert.strictEqual(times, 0, 'failed to close the watcher')
|
|
done()
|
|
}).catch(done)
|
|
})
|
|
})
|
|
|
|
t.test('should not watch after .close() is called', function(done) {
|
|
var dir = builder.getPath('home')
|
|
watcher = watch(dir, { delay: 0, recursive: true })
|
|
watcher.close()
|
|
|
|
watcher.getWatchedPaths(done.finish(function(dirs) {
|
|
assert.strictEqual(dirs.length, 0)
|
|
}))
|
|
})
|
|
})
|
|
|
|
t.describe('getWatchedPaths()', function() {
|
|
t.test('should get all the watched paths', function(done) {
|
|
var home = builder.getPath('home')
|
|
watcher = watch(home, { delay: 0, recursive: true })
|
|
|
|
watcher.getWatchedPaths(function(paths) {
|
|
hasNativeRecursive(done.finish(function(supportRecursive) {
|
|
var watched = supportRecursive
|
|
// The home directory is the only one that's being watched
|
|
// if the recursive option is natively supported.
|
|
? [home]
|
|
// Otherwise it should include all its subdirectories.
|
|
: builder.getAllDirectories()
|
|
|
|
assert.deepStrictEqual(
|
|
watched.sort(), paths.sort()
|
|
)
|
|
}))
|
|
})
|
|
})
|
|
|
|
t.test('should get its parent path instead of the file itself', function(done) {
|
|
var file = builder.getPath('home/a/file1')
|
|
// The parent path is actually being watched instead.
|
|
var parent = builder.getPath('home/a')
|
|
|
|
watcher = watch(file, { delay: 0 })
|
|
|
|
watcher.getWatchedPaths(done.finish(function(paths) {
|
|
assert.deepStrictEqual([parent], paths)
|
|
}))
|
|
})
|
|
|
|
t.test('should work correctly with composed watcher', function(done) {
|
|
var a = builder.getPath('home/a')
|
|
|
|
var b = builder.getPath('home/b')
|
|
var file = builder.getPath('home/b/file1')
|
|
|
|
var nested = builder.getPath('home/deep_node_modules')
|
|
var ma = builder.getPath('home/deep_node_modules/ma')
|
|
var mb = builder.getPath('home/deep_node_modules/mb')
|
|
var mc = builder.getPath('home/deep_node_modules/mc')
|
|
|
|
watcher = watch([a, file, nested], {
|
|
delay: 0,
|
|
recursive: true
|
|
})
|
|
|
|
watcher.getWatchedPaths(function(paths) {
|
|
hasNativeRecursive(done.finish(function(supportRecursive) {
|
|
var watched = supportRecursive
|
|
? [a, b, nested]
|
|
: [a, b, nested, ma, mb, mc]
|
|
|
|
assert.deepStrictEqual(
|
|
watched.sort(), paths.sort()
|
|
)
|
|
}))
|
|
})
|
|
})
|
|
})
|
|
})
|
|
}) |