test: Mock chokidar as CI filesystem seems unreliable

Author: pvdlg

package.json

@@ -51,7 +51,6 @@
     "karma-phantomjs-launcher": "^1.0.4",
     "nyc": "^11.0.3",
     "p-event": "^1.3.0",
-    "p-timeout": "^1.2.0",
     "pify": "^3.0.0",
     "postcss": "^6.0.8",
     "postcss-import": "^10.0.0",

test/helpers/karma.js

@@ -1,6 +1,7 @@
 import pEvent from 'p-event';
 import {Server, constants} from 'karma';
 import karmaPreprocessor from '../../lib/index';
+import {mockFactory} from './mock';
 
 /**
  * Base Karma configuration tu run preprocessor.
@@ -20,7 +21,6 @@ const KARMA_CONFIG = {
   colors: true,
   logLevel: constants.LOG_DISABLE,
   browsers: ['PhantomJS'],
-  plugins: ['@metahub/karma-jasmine-jquery', 'karma-*', karmaPreprocessor],
 };
 
 /**
@@ -45,7 +45,7 @@ const KARMA_CONFIG = {
  * @return {Promise<KarmaOutput>} A `Promise` that resolve to the Karma execution results.
  */
 export async function run(files, config) {
-  const server = createServer(files, config, false);
+  const server = createServer(files, config, false, karmaPreprocessor);
 
   server.start();
   const result = await waitForRunComplete(server);
@@ -64,11 +64,12 @@ export async function run(files, config) {
  * @param {Object} [config] configuration to pass to the preprocessor.
  * @return {Server} The started Karma Server.
  */
-export function watch(files, config) {
-  const server = createServer(files, config, true);
+export async function watch(files, config) {
+  const {factory, watcher} = mockFactory(true);
+  const server = createServer(files, config, true, factory);
 
   server.start();
-  return server;
+  return {server, watcher: await watcher};
 }
 
 /**
@@ -78,16 +79,18 @@ export function watch(files, config) {
  * @param {Array<string>} files path of the css files and unit tests.
  * @param {Object} [config] configuration to pass to the preprocessor.
  * @param {boolean} autoWatch `true` for autoWatch mode, `false` for a single run.
+ * @param {Object} processorFactory Karma plugin factory.
  * @return {Server} the configured Karma Server.
  */
-function createServer(files, config, autoWatch) {
+function createServer(files, config, autoWatch, processorFactory) {
   return new Server(
     Object.assign(KARMA_CONFIG, {
       files: Array.isArray(files) ? files : [files],
       postcssPreprocessor: config,
       customPreprocessors: {custom_postcss: Object.assign({base: 'postcss'}, config)},
       singleRun: !autoWatch,
       autoWatch,
+      plugins: ['@metahub/karma-jasmine-jquery', 'karma-*', processorFactory],
     }),
     () => 0
   );
@@ -104,7 +107,7 @@ export async function waitForRunComplete(server) {
   try {
     const [, result] = await pEvent(server, 'run_complete', {
       multiArgs: true,
-      timeout: 10000,
+      timeout: 50000,
       rejectionEvents: ['browser_error'],
     });
 

test/helpers/mock.js

@@ -1,45 +1,77 @@
+import {EventEmitter} from 'events';
 import proxyquire from 'proxyquire';
 import {spy, stub} from 'sinon';
 import pify from 'pify';
-import chokidar from 'chokidar';
 
 /**
- * @typedef {Object} Mock
+ * @typedef {Object} MockPreprocessor
  * @property {Function} preprocessor The preprocessor function.
  * @property {Spy} debug A spied debug log function.
  * @property {Spy} error A spied error log function.
  * @property {Spy} info A spied info log function.
  * @property {Spy} refreshFiles A spied server's refreshFiles function.
- * @property {Spy} add A spied watcher's add function.
- * @property {Spy} unwatch A spied watcher's unwatch function.
- * @property {FSWatcher} watcher The preprocessor local watcher.
+ * @property {EventEmitter} watcher The preprocessor local watcher.
+ * @property {Spy} watcher.add A spied watcher's add function.
+ * @property {Spy} watcher.unwatch A spied watcher's unwatch function.
  * @property {Stub} FSWatcher A stubbed local watcher constructor.
  */
 
+/**
+ * @typedef {Object} MockFactory
+ * @property {Oject} factory The preprocessor factory.
+ * @property {Promise<EventEmitter>} watcher a Promise that resolves to preprocessor local watcher.
+ * @property {Stub} FSWatcher A stubbed local watcher constructor.
+ */
+
+/**
+  * Create a mocked preprocessor factory.
+  * 
+  * @method mockFactory
+  * @param {Boolean} autoWatch `true` for autoWatch mode, `false` for a single run.
+  * @return {MockFactory} mocked preprocessor factory and watcher.
+  */
+export function mockFactory(autoWatch) {
+  const FSWatcher = stub();
+
+  return {
+    factory: proxyquire('../../lib/index', {chokidar: {FSWatcher}}),
+    watcher: pify(callback => {
+      if (autoWatch) {
+        return FSWatcher.callsFake(() => {
+          const emitter = new EventEmitter();
+          const add = spy();
+          const unwatch = spy();
+
+          emitter.add = add;
+          emitter.unwatch = unwatch;
+          callback(null, emitter);
+          return emitter;
+        });
+      } else {
+        FSWatcher.returns(new EventEmitter());
+        return callback(null);
+      }
+    })(),
+    FSWatcher,
+  };
+}
+
 /**
  * Create a mocked preprocessor.
  * 
  * @method mockPreprocessor
  * @param {Object} [args={}] custom preprocessor config to pass to the factory.
  * @param {Object} [config={}] Karma config to pass to the factory.
- * @return {Object} mocked preprocessor function and spies.
+ * @return {MockPreprocessor} mocked preprocessor function and spies.
  */
-export default function mockPreprocessor(args = {}, config = {}) {
-  let add;
-  let unwatch;
-  let watcher;
-  const FSWatcher = stub().callsFake((...watcherArgs) => {
-    watcher = new chokidar.FSWatcher(...watcherArgs);
-    add = spy(watcher, 'add');
-    unwatch = spy(watcher, 'unwatch');
-    return watcher;
-  });
+export async function mockPreprocessor(args = {}, config = {}) {
   const debug = spy();
   const error = spy();
   const info = spy();
   const refreshFiles = spy();
+  const {factory, watcher, FSWatcher} = mockFactory(config.autoWatch);
   const preprocessor = pify(
-    proxyquire('../../lib/index', {chokidar: {FSWatcher}})['preprocessor:postcss'][1](
+    factory['preprocessor:postcss'][1](
       args,
       config,
       {
@@ -51,5 +83,5 @@ export default function mockPreprocessor(args = {}, config = {}) {
     )
   );
 
-  return {preprocessor, debug, error, info, refreshFiles, add, unwatch, watcher, FSWatcher};
+  return {preprocessor, debug, error, info, refreshFiles, watcher: await watcher, FSWatcher};
 }

test/helpers/utils.js

@@ -15,31 +15,17 @@ export function tmp(filename) {
   return path.join('test/fixtures/.tmp', uuid(), filename || '');
 }
 
-/**
- * Return a Promise that resolve after a delay.
- * 
- * @method sleep
- * @param {Number} delay time after which to resolve the Promise.
- * @return {Promise} a Promise that resolve after a delay.
- */
-export function sleep(delay) {
-  // eslint-disable-next-line promise/avoid-new
-  return new Promise(resolve => {
-    setTimeout(resolve, delay);
-  });
-}
-
 /* eslint-disable no-magic-numbers */
 /**
  * Return a Promise that resolve when an event is emitted and reject after a timeout expire if the event is not emitted.
  *
  * @method waitFor
  * @param {Object} emitter object that emit events.
  * @param {string} event event to listen to.
- * @param {Number} [timeout=5000] maximum time to wait for the event to be emitted.
+ * @param {Number} [timeout=30000] maximum time to wait for the event to be emitted.
  * @return {Promise} Promise tht resolve when the event is emitted.
  */
-export function waitFor(emitter, event, timeout = 5000) {
+export function waitFor(emitter, event, timeout = 30000) {
   return pEvent(emitter, event, {timeout});
 }
 

test/integration.test.js

@@ -1,7 +1,6 @@
 import path from 'path';
-import {utimes, copy, readFile, outputFile} from 'fs-extra';
+import {copy} from 'fs-extra';
 import test from 'ava';
-import pTimeout from 'p-timeout';
 import cssnano from 'cssnano';
 import mixins from 'postcss-mixins';
 import simpleVars from 'postcss-simple-vars';
@@ -21,21 +20,27 @@ test.after(() => {
 });
 
 test('Compile css file', async t => {
-  const {success, error, disconnected} = await run(['test/fixtures/basic.css', 'test/fixtures/styles.test.js'], {
-    options: {plugins: [atImport, mixins, simpleVars, cssnano]},
-  });
+  const {success, error, disconnected, errMsg} = await run(
+    ['test/fixtures/basic.css', 'test/fixtures/styles.test.js'],
+    {
+      options: {plugins: [atImport, mixins, simpleVars, cssnano]},
+    }
+  );
 
-  t.ifError(error, 'Karma returned an error');
+  t.ifError(error, `Karma returned the error: ${errMsg}`);
   t.ifError(disconnected, 'Karma disconnected');
   t.is(success, 1, 'Expected 1 test successful');
 });
 
 test('Compile css file with custom preprocessor', async t => {
-  const {success, error, disconnected} = await run(['test/fixtures/basic.custom.css', 'test/fixtures/styles.test.js'], {
-    options: {plugins: [atImport, mixins, simpleVars, cssnano]},
-  });
+  const {success, error, disconnected, errMsg} = await run(
+    ['test/fixtures/basic.custom.css', 'test/fixtures/styles.test.js'],
+    {
+      options: {plugins: [atImport, mixins, simpleVars, cssnano]},
+    }
+  );
 
-  t.ifError(error, 'Karma returned an error');
+  t.ifError(error, `Karma returned the error: ${errMsg}`);
   t.ifError(disconnected, 'Karma disconnected');
   t.is(success, 1, 'Expected 1 test successful');
 });
@@ -63,67 +68,25 @@ test('Re-compile css file when dependency is modified', async t => {
     copy('test/fixtures/with-partial.css', fixture),
   ]);
 
-  const server = await watch(
+  const {server, watcher} = await watch(
     [fixture.replace('fixtures', '*').replace('with', '+(with|nomatch)'), 'test/fixtures/styles.test.js'],
     {options: {plugins: [atImport({path: [includePath]}), mixins, simpleVars, cssnano]}}
   );
 
   try {
-    let {success, error, disconnected} = await waitForRunComplete(server);
+    let {success, error, disconnected, errMsg} = await waitForRunComplete(server);
 
-    t.ifError(error, 'Karma returned an error');
+    t.ifError(error, `Karma returned the error: ${errMsg}`);
     t.ifError(disconnected, 'Karma disconnected');
     t.is(success, 1, 'Expected 1 test successful');
 
-    utimes(partial, Date.now() / 1000, Date.now() / 1000);
-    ({success, error, disconnected} = await waitForRunComplete(server));
+    watcher.emit('change', partial);
+    ({success, error, disconnected, errMsg} = await waitForRunComplete(server));
 
-    t.ifError(error, 'Karma returned an error');
+    t.ifError(error, `Karma returned the error: ${errMsg}`);
     t.ifError(disconnected, 'Karma disconnected');
     t.is(success, 1, 'Expected 1 test successful');
   } finally {
     await server.emitAsync('exit');
   }
 });
-
-test('Do not recompile css file when dependency is not imported anymore', async t => {
-  const dir = path.resolve(tmp());
-  const fixture = path.join(dir, 'with-partial.css');
-  const includePath = path.join(dir, 'partials');
-  const partial = path.join(includePath, 'partial.css');
-  const partialAlt = path.join(includePath, 'partial-alt.css');
-  const subPartial = path.join(includePath, 'sub-partial.css');
-
-  await Promise.all([
-    copy('test/fixtures/partials/partial.css', partial),
-    copy('test/fixtures/partials/partial.css', partialAlt),
-    copy('test/fixtures/partials/sub-partial.css', subPartial),
-    copy('test/fixtures/with-partial.css', fixture),
-  ]);
-
-  const server = await watch([fixture, 'test/fixtures/styles.test.js'], {
-    options: {plugins: [atImport({path: [includePath]}), mixins, simpleVars, cssnano]},
-  });
-
-  try {
-    let {success, error, disconnected} = await waitForRunComplete(server);
-
-    t.ifError(error, 'Karma returned an error');
-    t.ifError(disconnected, 'Karma disconnected');
-    t.is(success, 1, 'Expected 1 test successful');
-
-    await outputFile(
-      fixture,
-      (await readFile(fixture)).toString().replace(`@import 'partial';`, `@import 'partial-alt';`)
-    );
-    ({success, error, disconnected} = await waitForRunComplete(server));
-    t.ifError(error, 'Karma returned an error');
-    t.ifError(disconnected, 'Karma disconnected');
-    t.is(success, 1, 'Expected 1 test successful');
-
-    utimes(partial, Date.now() / 1000, Date.now() / 1000);
-    await t.throws(waitForRunComplete(server), pTimeout.TimeoutError);
-  } finally {
-    await server.emitAsync('exit');
-  }
-});