test: refactor (#298)

Author: ricardogobbosouza

package-lock.json

@@ -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' }]);
   });
 });

test/Linter.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);

test/autofix-stop.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);

test/autofix.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);

test/error.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);

test/eslint-path.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);

test/eslintignore.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();
+    });
+  });
 });

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 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();
+    });
+  });
 });

test/fail-on-warning.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);