test: refactor (#298)

webpack-contrib · Sep 25, 2019 · 0821e14 · 0821e14
1 parent 360e69c
commit 0821e14
Show file tree

Hide file tree

Showing 24 changed files with 132 additions and 302 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/test/Linter.test.js b/test/Linter.test.js
@@ -1,16 +1,19 @@
 import Linter from '../src/Linter';
 
-const loaderContext = { resourcePath: 'test' };
-const options = {
-  eslintPath: 'eslint',
-  ignore: false,
-  formatter: jest.fn(),
-};
-const res = { results: [{ filePath: '' }] };
-
 describe('Linter', () => {
   let linter;
+
   beforeAll(() => {
+    const loaderContext = {
+      resourcePath: 'test',
+    };
+
+    const options = {
+      eslintPath: 'eslint',
+      ignore: false,
+      formatter: jest.fn(),
+    };
+
     linter = new Linter(loaderContext, options);
   });
 
@@ -19,6 +22,10 @@ describe('Linter', () => {
   });
 
   it('should parse results correctly', () => {
+    const res = {
+      results: [{ filePath: '' }],
+    };
+
     expect(linter.parseResults(res)).toEqual([{ filePath: 'test' }]);
   });
 });
diff --git a/test/autofix-stop.test.js b/test/autofix-stop.test.js
@@ -1,16 +1,18 @@
+import { join } from 'path';
+
 import { copySync, removeSync } from 'fs-extra';
-import webpack from 'webpack';
 import chokidar from 'chokidar';
 
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('autofix stop', () => {
-  const entry = './test/fixtures/nonfixable-clone.js';
+  const entry = join(__dirname, 'fixtures/nonfixable-clone.js');
+
   let changed = false;
   let watcher;
 
   beforeAll(() => {
-    copySync('./test/fixtures/nonfixable.js', entry);
+    copySync(join(__dirname, 'fixtures/nonfixable.js'), entry);
 
     watcher = chokidar.watch(entry);
     watcher.on('change', () => {
@@ -24,16 +26,7 @@ describe('autofix stop', () => {
   });
 
   it('should not change file if there are no fixable errors/warnings', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry,
-        },
-        {
-          fix: true,
-        }
-      )
-    );
+    const compiler = pack('nonfixable-clone', { fix: true });
 
     compiler.run(() => {
       expect(changed).toBe(false);

diff --git a/test/autofix.test.js b/test/autofix.test.js
@@ -1,30 +1,22 @@
+import { join } from 'path';
+
 import { copySync, removeSync } from 'fs-extra';
-import webpack from 'webpack';
 
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('autofix stop', () => {
-  const entry = './test/fixtures/fixable-clone.js';
+  const entry = join(__dirname, 'fixtures/fixable-clone.js');
 
   beforeAll(() => {
-    copySync('./test/fixtures/fixable.js', entry);
+    copySync(join(__dirname, 'fixtures/fixable.js'), entry);
   });
 
   afterAll(() => {
     removeSync(entry);
   });
 
   it('should not throw error if file ok after auto-fixing', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry,
-        },
-        {
-          fix: true,
-        }
-      )
-    );
+    const compiler = pack('fixable-clone', { fix: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasWarnings()).toBe(false);

diff --git a/test/error.test.js b/test/error.test.js
@@ -1,14 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('error', () => {
   it('should return error if file is bad', (done) => {
-    const compiler = webpack(
-      conf({
-        entry: './test/fixtures/error.js',
-      })
-    );
+    const compiler = pack('error');
 
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(true);

diff --git a/test/eslint-path.test.js b/test/eslint-path.test.js
@@ -1,21 +1,11 @@
 import { join } from 'path';
 
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('eslint path', () => {
   it('should use another instance of eslint via eslintPath config', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/good.js',
-        },
-        {
-          eslintPath: join(__dirname, 'mock/eslint'),
-        }
-      )
-    );
+    const eslintPath = join(__dirname, 'mock/eslint');
+    const compiler = pack('good', { eslintPath });
 
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(true);

diff --git a/test/eslintignore.test.js b/test/eslintignore.test.js
@@ -1,19 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('eslintignore', () => {
   it('should ignores files present in .eslintignore', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/ignore.js',
-        },
-        {
-          ignore: true,
-        }
-      )
-    );
+    const compiler = pack('ignore', { ignore: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasWarnings()).toBe(false);

diff --git a/test/fail-on-error.test.js b/test/fail-on-error.test.js
@@ -1,21 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('fail on error', () => {
   it('should emits errors', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          cache: true,
-          entry: './test/fixtures/error.js',
-        },
-        {
-          failOnError: true,
-          cache: true,
-        }
-      )
-    );
+    const compiler = pack('error', { failOnError: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(true);
@@ -24,21 +11,20 @@ describe('fail on error', () => {
   });
 
   it('should correctly indentifies a success', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          cache: true,
-          entry: './test/fixtures/good.js',
-        },
-        {
-          failOnError: true,
-          cache: true,
-        }
-      )
-    );
+    const compiler = pack('good', { failOnError: true });
+
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(false);
       done();
     });
   });
+
+  it('should emits errors when cache enabled', (done) => {
+    const compiler = pack('error', { failOnError: true, cache: true });
+
+    compiler.run((err, stats) => {
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
 });
diff --git a/test/fail-on-warning.test.js b/test/fail-on-warning.test.js
@@ -1,21 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('fail on warning', () => {
   it('should emits errors', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          cache: true,
-          entry: './test/fixtures/warn.js',
-        },
-        {
-          failOnWarning: true,
-          cache: true,
-        }
-      )
-    );
+    const compiler = pack('warn', { failOnWarning: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(true);
@@ -24,21 +11,20 @@ describe('fail on warning', () => {
   });
 
   it('should correctly indentifies a success', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          cache: true,
-          entry: './test/fixtures/good.js',
-        },
-        {
-          failOnWarning: true,
-          cache: true,
-        }
-      )
-    );
+    const compiler = pack('good', { failOnWarning: true });
+
     compiler.run((err, stats) => {
       expect(stats.hasErrors()).toBe(false);
       done();
     });
   });
+
+  it('should emits errors when cache enabled', (done) => {
+    const compiler = pack('error', { failOnWarning: true, cache: true });
+
+    compiler.run((err, stats) => {
+      expect(stats.hasErrors()).toBe(true);
+      done();
+    });
+  });
 });
diff --git a/test/force-emit-error.test.js b/test/force-emit-error.test.js
@@ -1,19 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('force emit error', () => {
   it('should force to emit error', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/warn.js',
-        },
-        {
-          emitError: true,
-        }
-      )
-    );
+    const compiler = pack('warn', { emitError: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasWarnings()).toBe(false);

diff --git a/test/force-emit-warning.test.js b/test/force-emit-warning.test.js
@@ -1,19 +1,8 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('force emit warning', () => {
   it('should force to emit warning', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/error.js',
-        },
-        {
-          emitWarning: true,
-        }
-      )
-    );
+    const compiler = pack('error', { emitWarning: true });
 
     compiler.run((err, stats) => {
       expect(stats.hasWarnings()).toBe(true);

diff --git a/test/formatter-custom.test.js b/test/formatter-custom.test.js
@@ -1,19 +1,9 @@
-import webpack from 'webpack';
-
-import conf from './utils/conf';
+import pack from './utils/pack';
 
 describe('formatter eslint', () => {
   it('should use custom formatter as function', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/error.js',
-        },
-        {
-          formatter: require('eslint-friendly-formatter'),
-        }
-      )
-    );
+    const formatter = require('eslint-friendly-formatter');
+    const compiler = pack('error', { formatter });
 
     compiler.run((err, stats) => {
       expect(stats.compilation.errors[0].message).toBeTruthy();
@@ -22,16 +12,8 @@ describe('formatter eslint', () => {
   });
 
   it('should use custom formatter as string', (done) => {
-    const compiler = webpack(
-      conf(
-        {
-          entry: './test/fixtures/error.js',
-        },
-        {
-          formatter: 'eslint-friendly-formatter',
-        }
-      )
-    );
+    const formatter = 'eslint-friendly-formatter';
+    const compiler = pack('error', { formatter });
 
     compiler.run((err, stats) => {
       expect(stats.compilation.errors[0].message).toBeTruthy();