[Tests] fix eslint issues

.eslintrc

@@ -5,4 +5,13 @@
     "max-len": 0,
     "no-console": 0,
   },
+  "overrides": [{
+    "files": ["test/**/*.js"],
+    "env": {
+      "jest": true,
+    },
+    "rules": {
+      "global-require": "off",
+    },
+  }],
 }

package.json

@@ -12,7 +12,7 @@
     "postbuild": "cp src/*.json ./",
     "build:watch": "npm run build -- --watch",
     "clean": "rimraf *.js {commands,helpers,traversal} schema.json",
-    "lint": "eslint --ext=js,jsx src",
+    "lint": "eslint --ext=js,jsx --ignore-path=.gitignore .",
     "prepublish": "npm run build",
     "pretest": "npm run lint",
     "tests-only": "jest --coverage",

test/helpers/getComponents.js

@@ -3,11 +3,11 @@ import getComponents from '../../src/helpers/getComponents';
 
 jest.mock('../../src/helpers/validateProject', () => jest.fn());
 jest.mock('../../src/helpers/globToFiles', () => jest.fn(() => ['a', 'b', 'n']));
-jest.mock('../../src/helpers/requireFiles', () => jest.fn(paths => paths.reduce((obj, path) => ({
+jest.mock('../../src/helpers/requireFiles', () => jest.fn(paths => paths.reduce((obj, filePath) => ({
   ...obj,
-  [path]: {
-    actualPath: path,
-    Module: path >= 'foo' ? { default() {} } : { named() {} },
+  [filePath]: {
+    actualPath: filePath,
+    Module: filePath >= 'foo' ? { default() {} } : { named() {} },
   },
 }), {})));
 

test/helpers/getDescriptorFromProvider.js

@@ -69,7 +69,12 @@ describe('getDescriptorFromProvider', () => {
     const projectRoot = { root: '' };
     const getProjectExtras = require('../../src/helpers/getProjectExtras');
 
-    getDescriptorFromProvider(provider, { Components, projectConfig, projectRoot, getExtras });
+    getDescriptorFromProvider(provider, {
+      Components,
+      projectConfig,
+      projectRoot,
+      getExtras,
+    });
 
     expect(getProjectExtras).toHaveBeenCalledTimes(1);
     expect(getProjectExtras).toHaveBeenCalledWith(expect.objectContaining({
@@ -83,7 +88,6 @@ describe('getDescriptorFromProvider', () => {
     const descriptor = { a: 1 };
     const provider = () => descriptor;
     const Components = { components: '' };
-    const getExtras = () => {};
     const projectRoot = { root: '' };
 
     const result = getDescriptorFromProvider(provider, {
@@ -105,7 +109,6 @@ describe('getDescriptorFromProvider', () => {
     const descriptor = { a: 1, metadata: { b: 3, c: 4 } };
     const provider = () => descriptor;
     const Components = { components: '' };
-    const getExtras = () => {};
     const projectRoot = { root: '' };
 
     const result = getDescriptorFromProvider(provider, {

test/helpers/getVariationProviders.js

@@ -3,11 +3,11 @@ import getVariationProviders from '../../src/helpers/getVariationProviders';
 
 jest.mock('../../src/helpers/validateProject', () => jest.fn());
 jest.mock('../../src/helpers/globToFiles', () => jest.fn(() => ['a', 'b', 'n']));
-jest.mock('../../src/helpers/requireFiles', () => jest.fn(paths => paths.reduce((obj, path) => ({
+jest.mock('../../src/helpers/requireFiles', () => jest.fn(paths => paths.reduce((obj, filePath) => ({
   ...obj,
-  [path]: {
-    actualPath: path,
-    Module: path >= 'foo' ? { default() {} } : { named() {} },
+  [filePath]: {
+    actualPath: filePath,
+    Module: filePath >= 'foo' ? { default() {} } : { named() {} },
   },
 }), {})));
 

test/helpers/isValidProjectName.js

@@ -22,4 +22,4 @@ describe('isValidProjectName', () => {
   it('returns true if `projects` has a key for `project`', () => {
     expect(isValidProjectName({ foo: true }, 'foo')).toBe(true);
   });
-});
+});

test/traversal/forEachDescriptor.js

@@ -1,7 +1,8 @@
 import interopRequireDefault from '../../src/helpers/interopRequireDefault';
 import forEachDescriptor from '../../src/traversal/forEachDescriptor';
 
-let mockComponents, mockVariations;
+let mockComponents;
+let mockVariations;
 
 jest.mock('../../src/helpers/getComponents', () => jest.fn(() => mockComponents));
 jest.mock('../../src/helpers/getVariationProviders', () => jest.fn(() => mockVariations));
@@ -40,7 +41,9 @@ describe('forEachDescriptor', () => {
     });
 
     expect(() => forEachDescriptor(mockProjectConfig, { getDescriptor() {} })).toThrow(TypeError);
-    expect(() => forEachDescriptor(mockProjectConfig, { getDescriptor(a, b, c) {} })).toThrow(TypeError);
+    expect(() => forEachDescriptor(mockProjectConfig, {
+      getDescriptor(a, b, c) { return (a, b, c); },
+    })).toThrow(TypeError);
   });
 
   it('returns a function', () => {
@@ -70,10 +73,12 @@ describe('forEachDescriptor', () => {
   describe('traversal function', () => {
     const projectRoot = 'some root';
     const descriptor = {};
-    let getExtras, getDescriptor;
+    let getExtras;
+    let getDescriptor;
     beforeEach(() => {
       getExtras = jest.fn();
-      getDescriptor = jest.fn((x) => descriptor);
+      // eslint-disable-next-line no-unused-vars
+      getDescriptor = jest.fn(x => descriptor);
     });
 
     it('throws when `callback` is not a 1-arg function', () => {
@@ -88,9 +93,9 @@ describe('forEachDescriptor', () => {
       });
 
       expect(() => traverse(() => {})).toThrow(TypeError);
-      expect(() => traverse((a) => {})).not.toThrow(TypeError);
-      expect(() => traverse((a, b) => {})).not.toThrow(TypeError);
-      expect(() => traverse((a, b, c) => {})).toThrow(TypeError);
+      expect(() => traverse(a => ({ a }))).not.toThrow(TypeError);
+      expect(() => traverse((a, b) => ({ a, b }))).not.toThrow(TypeError);
+      expect(() => traverse((a, b, c) => ({ a, b, c }))).toThrow(TypeError);
     });
 
     it('throws with no components', () => {
@@ -146,7 +151,7 @@ describe('forEachDescriptor', () => {
       const Components = require('../../src/helpers/getComponents')();
       const variations = require('../../src/helpers/getVariationProviders')();
 
-      const callback = jest.fn((x) => {});
+      const callback = jest.fn(x => ({ x }));
       traverse(callback);
 
       expect(getDescriptor).toHaveBeenCalledTimes(2);
@@ -176,15 +181,15 @@ describe('forEachDescriptor', () => {
         variationProvider: {
           hierarchy: 'path/to/a',
           path: variationPathA,
-          resolvedPath: mockVariations[variationPathA].actualPath
+          resolvedPath: mockVariations[variationPathA].actualPath,
         },
         variationPath: variationPathA,
       }]);
       expect(second).toEqual([descriptor, {
         variationProvider: {
           hierarchy: 'path/to/b',
           path: variationPathB,
-          resolvedPath: mockVariations[variationPathB].actualPath
+          resolvedPath: mockVariations[variationPathB].actualPath,
         },
         variationPath: variationPathB,
       }]);
@@ -202,7 +207,7 @@ describe('forEachDescriptor', () => {
         projectRoot,
       });
 
-      const callback = jest.fn((x) => {});
+      const callback = jest.fn(x => ({ x }));
       expect(() => traverse(callback)).toThrow(TypeError);
     });
 
@@ -219,7 +224,7 @@ describe('forEachDescriptor', () => {
         projectRoot,
       });
 
-      const callback = jest.fn((x) => {});
+      const callback = jest.fn(x => ({ x }));
       traverse(callback);
 
       expect(getDescriptor).toHaveBeenCalledTimes(1);

test/traversal/forEachProject.js

@@ -7,10 +7,10 @@ describe('forEachProject', () => {
 
   it('throws when it receives a non-empty `projects` array', () => {
     [undefined, null, '', 'foo', {}, () => {}, true, 42, false].forEach((nonArray) => {
-      expect(() => forEachProject({}, nonArray, (x) => {})).toThrow(TypeError);
+      expect(() => forEachProject({}, nonArray, x => ({ x }))).toThrow(TypeError);
     });
 
-    expect(() => forEachProject({}, [], (x) => {})).toThrow(TypeError);
+    expect(() => forEachProject({}, [], x => ({ x }))).toThrow(TypeError);
   });
 
   const mockProjectConfig = {
@@ -19,10 +19,10 @@ describe('forEachProject', () => {
   };
 
   it('validates the project config', () => {
-    expect(() => forEachProject({ a: {}, b: mockProjectConfig }, ['a', 'b'], (x) => {})).toThrow(SyntaxError);
-    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['a', 'b'], (x) => {})).toThrow(SyntaxError);
-    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['b'], (x) => {})).toThrow(SyntaxError);
-    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['a'], (x) => {})).not.toThrow();
+    expect(() => forEachProject({ a: {}, b: mockProjectConfig }, ['a', 'b'], x => ({ x }))).toThrow(SyntaxError);
+    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['a', 'b'], x => ({ x }))).toThrow(SyntaxError);
+    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['b'], x => ({ x }))).toThrow(SyntaxError);
+    expect(() => forEachProject({ a: mockProjectConfig, b: {} }, ['a'], x => ({ x }))).not.toThrow();
   });
 
   it('throws if the callback is not a function with a length of 1 or 2', () => {
@@ -31,11 +31,11 @@ describe('forEachProject', () => {
     });
 
     expect(() => forEachProject({ a: mockProjectConfig }, ['a'], () => {})).toThrow(TypeError);
-    expect(() => forEachProject({ a: mockProjectConfig }, ['a'], (a, b, c) => {})).toThrow(TypeError);
+    expect(() => forEachProject({ a: mockProjectConfig }, ['a'], (a, b, c) => ({ a, b, c }))).toThrow(TypeError);
   });
 
   it('calls the callback with the expected arguments', () => {
-    const callback = jest.fn((x) => {});
+    const callback = jest.fn(x => ({ x }));
 
     const bProjectConfig = { ...mockProjectConfig, require: ['test'] };
 
@@ -47,7 +47,7 @@ describe('forEachProject', () => {
 
     expect(callback).toHaveBeenCalledTimes(2);
     const { calls: [aArgs, bArgs] } = callback.mock;
-    
+
     expect(aArgs).toEqual([
       'a',
       mockProjectConfig,
@@ -57,4 +57,4 @@ describe('forEachProject', () => {
       bProjectConfig,
     ]);
   });
-});
+});

test/traversal/forEachProjectVariation.js

@@ -36,15 +36,13 @@ jest.mock('../../src/helpers/getVariationProviders', () => jest.fn(() => ({
 const mockProjectNames = [mockProjectName, mockProjectName2];
 
 jest.mock('../../src/traversal/forEachVariation');
-jest.mock('../../src/helpers/getProjectRootConfig', () => (projectRoot, configPath) => {
-  return {
-    projects: {
-      [mockProjectName]: { ...mockProjectConfig },
-      [mockProjectName2]: { ...mockProjectConfig },
-    },
-    projectNames: mockProjectNames,
-  };
-});
+jest.mock('../../src/helpers/getProjectRootConfig', () => () => ({
+  projects: {
+    [mockProjectName]: { ...mockProjectConfig },
+    [mockProjectName2]: { ...mockProjectConfig },
+  },
+  projectNames: mockProjectNames,
+}));
 
 describe('forEachProjectVariation', () => {
   it('is a function', () => {
@@ -64,15 +62,14 @@ describe('forEachProjectVariation', () => {
       });
 
       expect(() => traverse(() => {})).toThrow(TypeError);
-      expect(() => traverse((a, b) => {})).toThrow(TypeError);
+      expect(() => traverse((a, b) => ({ a, b }))).toThrow(TypeError);
     });
   });
 
   it('invokes `forEachVariation` with the expected arguments', () => {
     const traverse = forEachProjectVariation(consumer);
-    const callback = (x) => {};
+    const callback = x => ({ x });
     const forEachVariation = require('../../src/traversal/forEachVariation');
-    const rootConfig = require('../../src/helpers/getProjectRootConfig')();
 
     traverse(callback);
 

test/traversal/forEachVariation.js

@@ -37,7 +37,7 @@ describe('forEachVariation', () => {
     });
 
     expect(() => forEachVariation(mockDescriptor, consumer, () => {})).toThrow(TypeError);
-    expect(() => forEachVariation(mockDescriptor, consumer, (a, b) => {})).toThrow(TypeError);
+    expect(() => forEachVariation(mockDescriptor, consumer, (a, b) => ({ a, b }))).toThrow(TypeError);
   });
 
   describe('callback function', () => {