test(*): add regression test on watch

Author: s-panferov

package.json

@@ -67,6 +67,8 @@
     "mocha": "^2.3.4",
     "ps-node": "0.0.5",
     "rimraf": "^2.5.0",
+    "sinon": "^1.17.4",
+    "temp": "^0.8.3",
     "tslint": "3.5.0-dev.1",
     "typescript": "^1.9.0-dev.20160509",
     "webpack": "2.1.0-beta.4"

src/test/checker.ts

@@ -49,7 +49,10 @@ describe('checker test', function() {
 
     it('should fork checker in separate process', async function() {
         await cleanOutputDir();
-        let watcher = await watch(config, () => {});
+
+        let watcher = watch(config);
+        await watcher.wait();
+
         let pid = await getCheckerRuntimeProcess();
         expect(pid).ok;
         watcher.close();
@@ -60,7 +63,10 @@ describe('checker test', function() {
         // I didn't get how to test it more precise, so it's more like a proof of work
 
         await cleanOutputDir();
-        let watcher = await watch(config, () => {});
+
+        let watcher = watch(config, () => {});
+        await watcher.wait();
+
         let pid = await getCheckerRuntimeProcess();
 
         expect(pid).ok;

src/test/utils.ts

@@ -2,6 +2,8 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as _ from 'lodash';
 
+const temp = require('temp').track();
+
 require('babel-polyfill');
 require('source-map-support').install();
 
@@ -133,17 +135,64 @@ export function compile(config): Promise<any> {
     });
 }
 
-export function watch(config, cb: (err, stats) => void): Promise<{ close(): void }> {
+export function watch(config, cb?: (err, stats) => void): Watch {
     let compiler = webpack(config);
-    return new Promise((resolve, reject) => {
-        let watcher = compiler.watch({}, (err, stats) => {
-            if (err) {
-                reject(err);
-            } else {
-                resolve(watcher);
-            }
-
+    let watch = new Watch();
+    let webpackWatcher = compiler.watch({}, (err, stats) => {
+        watch.call(err, stats);
+        if (cb) {
             cb(err, stats);
-        });
+        }
     });
+
+    watch.close = webpackWatcher.close;
+    return watch;
+}
+
+class Watch {
+    resolves: ((arg: any[]) => void)[] = [];
+    close: () => void;
+
+    call(err, stats) {
+        this.resolves.forEach(resolver => {
+            resolver([err, stats]);
+        });
+        this.resolves = [];
+    }
+
+    wait(): Promise<any> {
+        return new Promise((resolve, reject) => {
+            this.resolves.push(resolve);
+        });
+    }
+}
+
+export class Fixture {
+    private text: string;
+    private fileName: string;
+    constructor(text: string, ext = '.tsx') {
+        this.text = text;
+        let tmpobj = temp.openSync({
+            prefix: 'atl-',
+            suffix: '.tsx'
+        });
+
+        this.fileName = tmpobj.path;
+
+        fs.writeFileSync(this.fileName, text);
+    }
+
+    path() {
+        return this.fileName;
+    }
+
+    touch() {
+        touchFile(this.fileName);
+    }
+
+    update(updater: (text: string) => string) {
+        let newText = updater(this.text);
+        this.text = newText;
+        fs.writeFileSync(this.fileName, newText);
+    }
 }

src/test/watch-type-errors.ts

@@ -0,0 +1,43 @@
+import {
+    expect, Fixture, createConfig, cleanOutputDir, watch
+} from './utils';
+
+describe('checker test', function() {
+    this.timeout(5000);
+
+    let fixture = new Fixture(`
+        let a: string;
+        function check(arg1: string) { }
+        check(a);
+    `, '.ts');
+
+    let config = createConfig(
+        {
+            entry: fixture.path(),
+        },
+        {
+            watch: true,
+        }
+    );
+
+    it('should watch changes', async function() {
+        await cleanOutputDir();
+        let watcher = await watch(config);
+
+        {
+            const [err, stats] = await watcher.wait();
+            expect(err).not.ok;
+            expect(stats.compilation.errors).lengthOf(0);
+        }
+
+        {
+            fixture.update(text => text.replace('let a: string;', 'let a: number;'));
+
+            const [err, stats] = await watcher.wait();
+            expect(err).not.ok;
+            expect(stats.compilation.errors).lengthOf(1);
+        }
+
+        watcher.close();
+    });
+});