test: output tests

s-panferov · s-panferov · commit 8cecd9e6d731 · 2017-02-04T18:10:11.000+03:00
diff --git a/package.json b/package.json
@@ -33,7 +33,7 @@
   "homepage": "https://github.com/s-panferov/awesome-typescript-loader",
   "dependencies": {
     "colors": "^1.1.2",
-    "enhanced-resolve": "^3.0.3",
+    "enhanced-resolve": "^3.1.0",
     "loader-utils": "^0.2.16",
     "lodash": "^4.17.4",
     "object-assign": "^4.1.1",
@@ -42,9 +42,9 @@
   "devDependencies": {
     "@types/chai": "^3.4.34",
     "@types/colors": "^1.1.1",
-    "@types/lodash": "^4.14.51",
-    "@types/mocha": "^2.2.38",
-    "@types/node": "^7.0.4",
+    "@types/lodash": "^4.14.52",
+    "@types/mocha": "^2.2.39",
+    "@types/node": "^7.0.5",
     "@types/sinon": "^1.16.34",
     "bluebird": "^3.4.7",
     "chai": "^3.5.0",
@@ -58,6 +58,6 @@
     "temp": "^0.8.3",
     "tslint": "^4.4.2",
     "typescript": "^2.1.5",
-    "webpack": "2.2.0"
+    "webpack": "^2.2.1"
   }
 }
diff --git a/src/__test__/babel.ts b/src/__test__/babel.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, tsconfig, install,
-    watch, checkOutput, expectErrors, query, run
+    watch, checkOutput, expectErrors, query, spec
 } from './utils';
 
-run(__filename, async function() {
+spec(__filename, async function() {
     const index = src('index.ts', `
         class HiThere {
             constructor(a: number, b: string) {
diff --git a/src/__test__/compile-output.ts b/src/__test__/compile-output.ts
@@ -0,0 +1,59 @@
+import {
+    src, tsconfig, stdout, stderr,
+    spec, file, exec
+} from './utils';
+
+export function config(env) {
+    file(`webpack.config.js`, `
+        const path = require('path')
+        module.exports = {
+            entry: { index: path.join(process.cwd(), '${env.SRC_DIR}', 'index.ts') },
+            output: {
+                path: path.join(process.cwd(), '${env.OUT_DIR}'),
+                filename: '[name].js'
+            },
+            resolve: {
+                extensions: ['.ts', '.tsx', '.js', '.jsx'],
+            },
+            module: {
+                loaders: [
+                    {
+                        test: /\.(tsx?|jsx?)/,
+                        loader: path.resolve(process.cwd(), '..', '..', 'index.js'),
+                        include: [ path.join(process.cwd(), '${env.SRC_DIR}') ],
+                        query: {
+                            silent: true
+                        }
+                    }
+                ]
+            }
+        }
+    `);
+}
+
+spec(__filename, async function(env, done) {
+    src('index.ts', `
+        export default function sum(a: number, b: number) {
+            return a + b;
+        }
+
+        sum(1, '1');
+    `);
+
+    tsconfig();
+    config(env);
+
+    const webpack = exec('webpack');
+
+    await webpack.wait(
+        stderr('Checking finished with 1 errors'),
+        stdout([
+            'ERROR in [at-loader]',
+            `Argument of type '"1"' is not assignable to parameter of type 'number'`
+        ])
+    );
+
+    webpack.close();
+    done();
+});
+
diff --git a/src/__test__/declaration.ts b/src/__test__/declaration.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, tsconfig,
-    watch, checkOutput, expectErrors, run
+    watch, checkOutput, expectErrors, spec
 } from './utils';
 
-run(__filename, async function() {
+spec(__filename, async function() {
     const index = src('index.ts', `
         export { default as sum } from './utils/sum'
     `);
diff --git a/src/__test__/error.ts b/src/__test__/error.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, tsconfig,
-    compile, checkOutput, expectErrors, run
+    compile, checkOutput, expectErrors, spec
 } from './utils';
 
-run(__filename, async function() {
+spec(__filename, async function() {
     src('index.ts', `
         function sum(a: number, b: number) {
             return a + b;
diff --git a/src/__test__/react.ts b/src/__test__/react.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, expectErrors,
-    tsconfig, compile, install, entry, run
+    tsconfig, compile, install, entry, spec
 } from './utils';
 
-run(__filename, async function() {
+spec(__filename, async function() {
     install(
         'react',
         'react-dom',
diff --git a/src/__test__/remove.ts b/src/__test__/remove.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, tsconfig,
-    watch, expectErrors, xrun
+    watch, expectErrors, xspec
 } from './utils';
 
-xrun(__filename, async function() {
+xspec(__filename, async function() {
     const index = src('index.ts', `
         import sum from './sum'
         import mul from './mul'
diff --git a/src/__test__/simple.ts b/src/__test__/simple.ts
@@ -1,9 +1,9 @@
 import {
     src, webpackConfig, tsconfig,
-    compile, checkOutput, expectErrors, run
+    compile, checkOutput, expectErrors, spec
 } from './utils';
 
-run(__filename, async function() {
+spec(__filename, async function() {
     src('index.ts', `
         class HiThere {
             constructor(a: number, b: string) {
diff --git a/src/__test__/utils.ts b/src/__test__/utils.ts
@@ -31,6 +31,10 @@ export interface ConfigOptions {
 const TEST_DIR = path.join(process.cwd(), '.test');
 const SRC_DIR = './src';
 const OUT_DIR = './out';
+const WEBPACK = path.join(
+    path.dirname(
+        path.dirname(
+            require.resolve('webpack'))), 'bin', 'webpack.js');
 
 mkdirp.sync(TEST_DIR);
 
@@ -80,6 +84,130 @@ export function webpackConfig(...enchance: any[]) {
     return config;
 }
 
+export interface Output {
+    type: 'stderr' | 'stdout';
+    data: string;
+}
+
+export type OutputMatcher = (o: Output) => boolean;
+
+export class Exec {
+    process: child.ChildProcess;
+    watchers: {
+        resolve: any,
+        reject: any,
+        matchers: OutputMatcher[],
+    }[] = [];
+
+    close() {
+        this.process.kill();
+    }
+
+    invoke({stdout, stderr}) {
+        this.watchers = this.watchers.filter(watcher => {
+            const output: Output  = {
+                type: stdout ? 'stdout' : 'stderr',
+                data: stdout || stderr
+            };
+
+            const index = watcher.matchers.findIndex(m => m(output));
+
+            if (index === -1) {
+                watcher.reject(new Error(`Unexpected ${output.type}:\n${output.data}`));
+                return false;
+            }
+
+            watcher.matchers.splice(index, 1);
+            if (watcher.matchers.length === 0) {
+                watcher.resolve();
+                return false;
+            } else {
+                return true;
+            }
+        });
+    }
+
+    wait(...matchers: OutputMatcher[]): Promise<any> {
+        return new Promise((resolve, reject) => {
+            const watcher = {
+                resolve,
+                reject,
+                matchers,
+            };
+
+            this.watchers.push(watcher);
+        });
+    }
+
+    alive(): Promise<any> {
+        return new Promise((resolve, reject) => {
+            this.process.on('exit', resolve);
+        });
+    }
+}
+
+export type Test = string | (string | [boolean, string])[] | RegExp | ((str: string) => boolean);
+export function streamTest(stream = 'stdout', test: Test) {
+    let matcher: (str: string) => boolean;
+
+    if (typeof test === 'string') {
+        matcher = (o: string) => o.indexOf(test) !== -1;
+    } else if (Array.isArray(test)) {
+        matcher = (o: string) => test.every(test => {
+            if (typeof test === 'string') {
+                return o.indexOf(test) !== -1;
+            } else {
+                const [flag, str] = test;
+                if (flag) {
+                     return o.indexOf(str) !== -1;
+                } else {
+                    return o.indexOf(str) === -1;
+                }
+            }
+        });
+    } else if (test instanceof RegExp) {
+        matcher => (o: string) => test.test(o);
+    } else {
+        matcher = test;
+    }
+
+    return (o: Output) => (o.type === stream) && matcher(o.data);
+}
+
+export const stdout = (test: Test) => streamTest('stdout', test);
+export const stderr = (test: Test) => streamTest('stderr', test);
+
+export function exec(command: string, args?: string[], options?: child.SpawnOptions) {
+    const p = child.spawn('node', [WEBPACK].concat(args), {
+        shell: false,
+        stdio: 'pipe',
+        env: process.env
+    });
+
+    const waiter = new Exec();
+
+    p.stdout.on('data', (data) => {
+        console.log(data.toString());
+        waiter.invoke({ stdout: data.toString(), stderr: null });
+    });
+
+    p.stderr.on('data', (data) => {
+        console.error(data.toString());
+        waiter.invoke({ stdout: null, stderr: data.toString() });
+    });
+
+    process.on('beforeExit', () => {
+        p.kill();
+    });
+
+    process.on('exit', () => {
+        p.kill();
+    });
+
+    waiter.process = p;
+    return waiter;
+}
+
 export function expectErrors(stats: any, count: number, errors: string[] = []) {
     stats.compilation.errors.every(err => {
         const str = err.toString();
@@ -109,7 +237,7 @@ export function json(obj) {
 export function checkOutput(fileName: string, fragment: string) {
     const source = readOutput(fileName);
 
-    if (!source) { process.exit() }
+    if (!source) { process.exit(); }
 
     expect(source.replace(/\s/g, '')).include(fragment.replace(/\s/g, ''));
 }
@@ -138,8 +266,16 @@ export function compile(config?): Promise<any> {
     });
 }
 
-export function run<T>(name: string, cb: () => Promise<T>, disable = false) {
-    const runner = () => {
+export interface TestEnv {
+    TEST_DIR: string;
+    OUT_DIR: string;
+    SRC_DIR: string;
+    LOADER: string;
+    WEBPACK: string;
+}
+
+export function spec<T>(name: string, cb: (env: TestEnv, done?: () => void) => Promise<T>, disable = false) {
+    const runner = (done?) => {
         const temp = path.join(
             TEST_DIR,
             path.basename(name).replace('.', '') + '-' +
@@ -152,7 +288,16 @@ export function run<T>(name: string, cb: () => Promise<T>, disable = false) {
         let cwd = process.cwd();
         process.chdir(temp);
         pkg();
-        const promise = cb();
+
+        const env = {
+            TEST_DIR,
+            OUT_DIR,
+            SRC_DIR,
+            LOADER,
+            WEBPACK
+        };
+
+        const promise = cb(env, done);
         return promise
             .then(a => {
                 process.chdir(cwd);
@@ -164,15 +309,19 @@ export function run<T>(name: string, cb: () => Promise<T>, disable = false) {
             });
     };
 
+    const asyncRunner = cb.length === 2
+        ? (done) => { runner(done).catch(done); return; }
+        : () => runner();
+
     if (disable) {
-        xit(name, runner);
+        xit(name, asyncRunner);
     } else {
-        it(name, runner);
+        it(name, asyncRunner);
     }
 }
 
-export function xrun<T>(name: string, cb: () => Promise<T>) {
-    return run(name, cb, true);
+export function xspec<T>(name: string, cb: () => Promise<T>) {
+    return spec(name, cb, true);
 }
 
 export function watch(config, cb?: (err, stats) => void): Watch {
diff --git a/src/__test__/watch-output.ts b/src/__test__/watch-output.ts
diff --git a/src/__test__/watch.ts b/src/__test__/watch.ts
diff --git a/yarn.lock b/yarn.lock
