Tests

Author: Piotr Oleś

test/CancellationToken.spec.js

@@ -1,5 +1,115 @@
 var describe = require('mocha').describe;
+var it = require('mocha').it;
+var os = require('os');
+var ts = require('typescript');
+var fs = require('fs');
+var beforeEach = require('mocha').beforeEach;
+var afterEach = require('mocha').afterEach;
+var expect = require('chai').expect;
+var mockFs = require('mock-fs');
+var CancellationToken = require('../lib/CancellationToken');
 
 describe('CancellationToken', function () {
-  // TODO...
+  beforeEach(function () {
+    var fsTree = {};
+    fsTree[os.tmpdir()] = mockFs.directory();
+
+    mockFs(fsTree);
+  });
+
+  afterEach(function () {
+    mockFs.restore();
+  });
+
+  it('should create valid cancellation token', function () {
+    var tokenA = new CancellationToken();
+    expect(tokenA.isCancellationRequested()).to.be.false;
+
+    var tokenB = new CancellationToken('FA#FERgSERgRT$rA$#rA#Ea@RweFRgERG');
+    expect(tokenB.isCancellationRequested()).to.be.false;
+
+    var tokenC = new CancellationToken('GFERWgEgeF#R2erwreWrweWER', false);
+    expect(tokenC.isCancellationRequested()).to.be.false;
+
+    var tokenD = new CancellationToken('REGg$#R2$#@r@#R$#T43T$#t43t', true);
+    expect(tokenD.isCancellationRequested()).to.be.true;
+  });
+
+  it('should serialize to JSON', function () {
+    var tokenA = new CancellationToken();
+    var json = JSON.stringify(tokenA);
+
+    expect(json).to.be.a('string');
+    expect(function() { JSON.parse(json); }).to.not.throw(Error);
+    expect(JSON.parse(json)).to.be.a('object');
+
+    var tokenB = CancellationToken.createFromJSON(JSON.parse(json));
+    expect(tokenA.getCancellationFilePath()).to.be.equal(tokenB.getCancellationFilePath());
+    expect(tokenA.isCancellationRequested()).to.be.equal(tokenB.isCancellationRequested());
+  });
+
+  it('should generate path in os.tmpdir() directory', function () {
+    var tokenA = new CancellationToken();
+
+    expect(tokenA.getCancellationFilePath().indexOf(os.tmpdir())).to.be.equal(0);
+  });
+
+  it('should throw ts.OperationCanceledException error on cancelled', function () {
+    var tokenA = new CancellationToken();
+    expect(function () { tokenA.throwIfCancellationRequested(); }).to.not.throw();
+
+    var tokenB = new CancellationToken('rgeer#R23r$#T$3t#$t43', true);
+    expect(function () { tokenB.throwIfCancellationRequested(); }).to.throw(ts.OperationCanceledException);
+  });
+
+  it('should write file in filesystem on requestCancellation', function () {
+    var tokenA = new CancellationToken();
+    tokenA.requestCancellation();
+
+    expect(tokenA.isCancellationRequested()).to.be.true;
+    expect(fs.existsSync(tokenA.getCancellationFilePath())).to.be.true;
+  });
+
+  it('should cleanup file on cleanupCancellation', function () {
+    var tokenA = new CancellationToken();
+    tokenA.requestCancellation();
+    tokenA.cleanupCancellation();
+
+    expect(tokenA.isCancellationRequested()).to.be.false;
+    expect(fs.existsSync(tokenA.getCancellationFilePath())).to.be.false;
+
+    // make sure we can call it as many times as we want to
+    expect(function() { tokenA.cleanupCancellation(); }).to.not.throw(Error);
+    expect(tokenA.isCancellationRequested()).to.be.false;
+  });
+
+  it('should not throw error on cleanupCancellation with no file exists', function () {
+    var tokenA = new CancellationToken('some_file_that_doesnt_exists', true);
+
+    expect(function() { tokenA.cleanupCancellation(); }).to.not.throw();
+    expect(function() { tokenA.cleanupCancellation(); }).to.not.throw();
+  });
+
+  it('should throttle check for 10ms', function (done) {
+    var tokenA = new CancellationToken();
+    var tokenB = CancellationToken.createFromJSON(tokenA.toJSON());
+    var start = Date.now();
+
+    expect(tokenA.isCancellationRequested()).to.be.false;
+    expect(tokenB.isCancellationRequested()).to.be.false;
+
+    tokenA.requestCancellation();
+    expect(tokenA.isCancellationRequested()).to.be.true;
+
+    var duration = Math.abs(Date.now() - start);
+    if (duration < 10) {
+      // we should throttle check
+      expect(tokenB.isCancellationRequested()).to.be.false;
+    }
+
+    setTimeout(function () {
+      expect(tokenB.isCancellationRequested()).to.be.true;
+      done();
+    }, 11);
+  });
 });

test/FileRegister.spec.js

@@ -1,5 +1,101 @@
 var describe = require('mocha').describe;
+var it = require('mocha').it;
+var beforeEach = require('mocha').beforeEach;
+var expect = require('chai').expect;
+var FilesRegister = require('../lib/FilesRegister');
 
 describe('FilesRegister', function () {
-  // TODO...
+  var register;
+  beforeEach(function () {
+    register = new FilesRegister(function () {
+      return {
+        test: true
+      };
+    });
+  });
+
+  it('should add and remove files', function () {
+    register.add('/test');
+    register.add('/test2');
+    expect(register.has('/test')).to.be.true;
+    expect(register.has('/test2')).to.be.true;
+    register.remove('/test');
+    expect(register.has('/test')).to.be.false;
+    expect(register.has('/test2')).to.be.true;
+
+    expect(function() { register.remove('/test'); }).to.not.throw();
+    register.remove('/test2');
+    expect(register.has('/test')).to.be.false;
+    expect(register.has('/test2')).to.be.false;
+  });
+
+  it('should get file that exists in register', function () {
+    register.add('/test');
+    expect(function() { register.get('/test'); }).to.not.throw();
+    expect(function() { register.get('/test2'); }).to.throw();
+    expect(register.get('/test')).to.be.a('object');
+    expect(Object.keys(register.get('/test'))).to.be.deep.equal(['mtime', 'data']);
+  });
+
+  it('should list all keys in register', function () {
+    register.add('/test');
+    register.add('/test/foo');
+    register.add('/test/foo/bar');
+    expect(register.keys()).to.be.deep.equal(['/test', '/test/foo', '/test/foo/bar']);
+
+    register.remove('/test');
+    expect(register.keys()).to.be.deep.equal(['/test/foo', '/test/foo/bar']);
+  });
+
+  it('should get data from file', function () {
+    register.add('/test');
+    expect(register.getData('/test')).to.be.deep.equal({ test: true });
+    expect(function() { register.getData('/test2'); }).to.throw(Error);
+  });
+
+  it('should ensure if file exists', function () {
+    expect(register.has('/test')).to.be.false;
+    register.ensure('/test');
+    expect(register.has('/test')).to.be.true;
+
+    var reference = register.get('/test');
+    register.ensure('/test');
+    expect(reference).to.be.equal(register.get('/test'));
+  });
+
+  it('should mutate existing data', function () {
+    register.add('/test');
+    var dataReference = register.getData('/test');
+    expect(dataReference.test).to.be.true;
+    register.mutateData('/test', function (data) {
+      data.test = false;
+    });
+    expect(dataReference).to.be.equal(register.getData('/test'));
+    expect(dataReference.test).to.be.false;
+  });
+
+  it('should set mtime and reset data if mtime changes', function () {
+    register.add('/test');
+    register.mutateData('/test', function (data) {
+      data.test = false;
+    });
+    expect(register.getData('/test').test).to.be.false;
+    expect(register.getMtime('/test')).to.be.undefined;
+
+    register.setMtime('/test', 1000);
+    expect(register.getMtime('/test')).to.be.equal(1000);
+    expect(register.getData('/test').test).to.be.true;
+    register.mutateData('/test', function (data) {
+      data.test = false;
+    });
+    expect(register.getData('/test').test).to.be.false;
+
+    register.setMtime('/test', 1000);
+    expect(register.getMtime('/test')).to.be.equal(1000);
+    expect(register.getData('/test').test).to.be.false;
+
+    register.setMtime('/test', 1001);
+    expect(register.getMtime('/test')).to.be.equal(1001);
+    expect(register.getData('/test').test).to.be.true;
+  });
 });

test/FilesWatcher.spec.js

@@ -1,5 +1,151 @@
 var describe = require('mocha').describe;
+var it = require('mocha').it;
+var beforeEach = require('mocha').beforeEach;
+var afterEach = require('mocha').afterEach;
+var sinon = require('sinon');
+var expect = require('chai').expect;
+var mockRequire = require('mock-require');
 
 describe('FilesWatcher', function () {
-  // TODO...
+  var FilesWatcher;
+  var watcher;
+  var watchStub;
+  var watcherStub;
+
+  beforeEach(function () {
+    watcherStub = {
+      on: sinon.stub().returnsThis()
+    };
+    watchStub = sinon.stub().returns(watcherStub);
+
+    mockRequire('chokidar', { watch: watchStub });
+    FilesWatcher = mockRequire.reRequire('../lib/FilesWatcher');
+
+    watcher = new FilesWatcher(
+      ['/test', '/bar'],
+      ['.ext1', '.ext2']
+    );
+  });
+
+  afterEach(function () {
+    mockRequire.stopAll();
+  });
+
+  it('should check if file is supported', function () {
+    expect(watcher.isFileSupported('/foo.ext1')).to.be.true;
+    expect(watcher.isFileSupported('/foo.ext2')).to.be.true;
+    expect(watcher.isFileSupported('/foo.txt')).to.be.false;
+    expect(watcher.isFileSupported('/foo.ext1.txt')).to.be.false;
+  });
+
+  it('should check if is watching file', function () {
+    expect(watcher.isWatchingFile('/test/a.ext1')).to.be.false;
+    expect(watcher.isWatchingFile('/test/a.txt')).to.be.false;
+    expect(watcher.isWatchingFile('/test')).to.be.false;
+    expect(watcher.isWatchingFile('/foo/a.ext1')).to.be.false;
+
+    watcher.watch();
+
+    expect(watcher.isWatchingFile('/test/a.ext1')).to.be.true;
+    expect(watcher.isWatchingFile('/test/a.txt')).to.be.false;
+    expect(watcher.isWatchingFile('/test')).to.be.false;
+    expect(watcher.isWatchingFile('/foo/a.ext1')).to.be.false;
+  });
+
+  it('should check if watcher is watching', function () {
+    expect(watcher.isWatching()).to.be.false;
+    watcher.watch();
+    expect(watcher.isWatching()).to.be.true;
+    expect(function () { watcher.watch(); }).to.throw(Error);
+  });
+
+  it('should add and remove listeners', function () {
+    var listenerA = function () {
+    };
+    var listenerB = function () {
+    };
+
+    expect(watcher.listeners).to.be.a('object');
+    watcher.on('event', listenerA);
+    watcher.on('event', listenerB);
+    expect(watcher.listeners['event']).to.be.a('array');
+    expect(watcher.listeners['event']).to.be.deep.equal([listenerA, listenerB]);
+
+    watcher.off('event', listenerA);
+    expect(watcher.listeners['event']).to.be.deep.equal([listenerB]);
+
+    expect(function() { watcher.off('event', listenerA); }).to.not.throw();
+    expect(watcher.listeners['event']).to.be.deep.equal([listenerB]);
+
+    watcher.off('event', listenerB);
+    expect(watcher.listeners['event']).to.be.deep.equal([]);
+
+    expect(watcher.listeners['foo']).to.be.undefined;
+    expect(function() { watcher.off('foo', listenerA); }).to.not.throw();
+
+    expect(watcher.listeners['foo']).to.be.undefined;
+  });
+
+  it('should watch filesystem using chokidar', function () {
+    expect(watchStub.called).to.be.false;
+
+    var changeListenerA = sinon.spy();
+    var changeListenerB = sinon.spy();
+    var unlinkListenerA = sinon.spy();
+    var unlinkListenerB = sinon.spy();
+
+    watcher.watch();
+
+    expect(watcherStub.on.getCall(0).args[0]).to.be.equal('change');
+    expect(watcherStub.on.getCall(1).args[0]).to.be.equal('unlink');
+
+    var triggerChange = watcherStub.on.getCall(0).args[1];
+    var triggerUnlink = watcherStub.on.getCall(1).args[1];
+
+    expect(triggerChange).to.be.a('function');
+    expect(triggerUnlink).to.be.a('function');
+
+    expect(function() { triggerChange('/test/test.ext1', {}); }).to.not.throw();
+    expect(function() { triggerUnlink('/test/test.ext1', {}); }).to.not.throw();
+
+    watcher.on('change', changeListenerA);
+    watcher.on('change', changeListenerB);
+    watcher.on('unlink', unlinkListenerA);
+    watcher.on('unlink', unlinkListenerB);
+
+    expect(watchStub.called).to.be.true;
+    expect(watchStub.getCall(0).args[0]).to.be.equal('/test');
+    expect(watchStub.getCall(1).args[0]).to.be.equal('/bar');
+
+    // manually trigger change listeners
+    triggerChange('/test/test.txt', {});
+    expect(changeListenerA.called).to.be.false;
+    expect(changeListenerB.called).to.be.false;
+
+    triggerChange('/test/test.ext1', {});
+    expect(changeListenerB.called).to.be.true;
+    expect(changeListenerB.called).to.be.true;
+
+
+    // manually trigger unlink listeners
+    triggerUnlink('/test/test.txt');
+    expect(unlinkListenerA.called).to.be.false;
+    expect(unlinkListenerB.called).to.be.false;
+
+    triggerUnlink('/test/test.ext1');
+    expect(unlinkListenerA.called).to.be.true;
+    expect(unlinkListenerB.called).to.be.true;
+
+    // check if off is working properly
+    watcher.off('change', changeListenerA);
+    watcher.off('unlink', unlinkListenerB);
+
+    triggerChange('/test/test.ext1', {});
+    triggerUnlink('/test/test.ext1');
+
+    expect(changeListenerA.callCount).to.be.equal(1);
+    expect(changeListenerB.callCount).to.be.equal(2);
+    expect(unlinkListenerA.callCount).to.be.equal(2);
+    expect(unlinkListenerB.callCount).to.be.equal(1);
+  });
 });