test: refactor to use chain function 🎨

- implement chain-of-responsibility pattern
- the chainer are called `on` function
- ignore prettier rule on test files
- change loader.test.js to use `on` function

Author: DrSensor

.eslintrc.js

@@ -8,6 +8,17 @@ module.exports = {
       { singleQuote: true, trailingComma: 'es5', arrowParens: 'always' },
     ],
     'prefer-destructuring': ['error', {'object': true, 'array': false}],
+    'newline-per-chained-call': ['error', { 'ignoreChainWithDepth': 4 }],
     'line-comment-position': ['off'],
   },
+  overrides: [{
+    files: ['*.test.*', 'on.js'],
+    rules: {
+      'semi': ['error', 'always', { 'omitLastInOneLineBlock': true }],
+      'quotes': ['error', 'single'],
+      'comma-dangle': ['error', 'always-multiline'],
+      'arrow-parens': ['error', 'as-needed'],
+      'prettier/prettier': 'off',
+    }
+  }]
 };

.prettierignore

@@ -0,0 +1 @@
+*.test.*

test/helpers/on.js

@@ -0,0 +1,72 @@
+import { statSync } from 'fs';
+import { resolve, dirname } from 'path';
+
+// TODO: test approximate size (need ability to convert Unit, e.g kb to KB)
+
+function inLoopExpect(array, prop, isNot = false) {
+  return {
+    get not() {
+      return inLoopExpect(array, prop, true);
+    },
+
+    toContain(expected) {
+      for (const element of array) {
+        if (isNot) {
+          if (prop) expect(element[prop]).not.toContain(expected);
+          else expect(element).not.toContain(expected);
+        } else if (prop) expect(element[prop]).toContain(expected);
+        else expect(element).toContain(expected);
+      }
+    },
+
+    toBeLessThan(expected) {
+      for (const element of array) {
+        if (isNot) {
+          if (prop) expect(element[prop]).not.toBeLessThan(expected);
+          else expect(element).not.toBeLessThan(expected);
+        } else if (prop) expect(element[prop]).toBeLessThan(expected);
+        else expect(element).toBeLessThan(expected);
+      }
+    },
+
+    toMatchSnapshot() {
+      for (const element of array) {
+        if (isNot) {
+          if (prop) expect(element[prop]).not.toMatchSnapshot();
+          else expect(element).not.toMatchSnapshot();
+        } else if (prop) expect(element[prop]).toMatchSnapshot();
+        else expect(element).toMatchSnapshot();
+      }
+    },
+  };
+}
+
+function chainer(statModules) {
+  return {
+    get: prop => inLoopExpect(statModules, prop),
+    get source() { return inLoopExpect(statModules, 'source') },
+    get providedExports() { return inLoopExpect(statModules, 'providedExports') },
+
+    get originSize() {
+      return inLoopExpect(
+        statModules.map(({ issuer, name }) => statSync(resolve(dirname(issuer), name)).size)
+      );
+    },
+
+    withExtension(extension) {
+      return chainer(
+        statModules.filter(({ name }) => name.includes(extension))
+      );
+    },
+
+    withoutExtension(extension) {
+      return chainer(
+        statModules.filter(({ name }) => !name.includes(extension))
+      );
+    },
+  };
+}
+
+export default function(stats) {
+  return chainer(stats.toJson().modules);
+}

test/loader.test.js

@@ -1,4 +1,5 @@
 import webpack from './helpers/compiler';
+import on from './helpers/on';
 
 describe('Loader', () => {
   describe('Defaults', () => {
@@ -10,38 +11,22 @@ describe('Loader', () => {
 
     test('match snapshots', async () => {
       const stats = await webpack('fixture.js', config);
-      for (const { source } of stats.toJson().modules)
-        expect(source).toMatchSnapshot();
+      on(stats).source.toMatchSnapshot();
     });
 
     test('indeed from rust code', async () => {
       const stats = await webpack('fixture.js', config);
-      stats
-        .toJson()
-        .modules.filter(({ name }) => name.includes('.rust.wasm'))
-        .forEach(({ providedExports }) =>
-          expect(providedExports).toContain('rust_eh_personality')
-        );
+      on(stats).withExtension('.rust.wasm').providedExports.toContain('rust_eh_personality');
     });
 
     test('not from rust code', async () => {
       const stats = await webpack('fixture.js', config);
-      stats
-        .toJson()
-        .modules.filter(({ name }) => !name.includes('.rust.wasm'))
-        .forEach(({ providedExports }) =>
-          expect(providedExports).not.toContain('rust_eh_personality')
-        );
+      on(stats).withoutExtension('.rust.wasm').providedExports.not.toContain('rust_eh_personality');
     });
 
     test('all wasm must specify the allocated memory', async () => {
       const stats = await webpack('fixture.js', config);
-      stats
-        .toJson()
-        .modules.filter(({ name }) => name.includes('.wasm'))
-        .forEach(({ providedExports }) =>
-          expect(providedExports).toContain('memory')
-        );
+      on(stats).withExtension('.wasm').providedExports.toContain('memory');
     });
   });
 });