Remove traces of linting tests

Long time ago linters were run as tests. And ember-exam was splitting
tests into partitions in lint aware style because linting tests are much
faster than regular tests.

Nowadays we don't run linters as tests and this feature is no longer
necessary. Remove it from the code to avoid the confusion of the future
generations.

The initial driver for this change was a failing test which was
complaining on something related to jshint and potentially it was caused
by removal of jshint support from ember-cli.

Author: Andrey Fel

README.md

@@ -288,7 +288,7 @@ $ ember exam --file-path='/my-application/tests/unit/*.js'
 $ ember exam --parallel=<num> --load-balance
 ```
 
-The `load-balance` option allows you to load balance test files against multiple browsers. It will order the test files by test types, e.g. acceptance | integration | unit | eslint, and load balance the ordered test files between the browsers dynamically rather than statically.
+The `load-balance` option allows you to load balance test files against multiple browsers. It will order the test files by test types, e.g. acceptance | integration | unit, and load balance the ordered test files between the browsers dynamically rather than statically.
 **Note:** parallel must be used along with load-balance to specify a number of browser(s)
 
 The `load-balance` option was added to version 1.1 to address execution performance when running against a large test suite.

addon-test-support/-private/split-test-modules.js

@@ -8,25 +8,16 @@ function createGroups(num) {
   return groups;
 }
 
-function filterIntoGroups(arr, filter, numGroups) {
-  const filtered = arr.filter(filter);
+function splitIntoGroups(arr, numGroups) {
   const groups = createGroups(numGroups);
 
-  for (let i = 0; i < filtered.length; i++) {
-    groups[i % numGroups].push(filtered[i]);
+  for (let i = 0; i < arr.length; i++) {
+    groups[i % numGroups].push(arr[i]);
   }
 
   return groups;
 }
 
-function isLintTest(name) {
-  return name.match(/\.(jshint|(es)?lint-test)$/);
-}
-
-function isNotLintTest(name) {
-  return !isLintTest(name);
-}
-
 /**
  * Splits the list of modules into unique subset of modules
  * return the subset indexed by the partition
@@ -43,8 +34,7 @@ export default function splitTestModules(modules, split, partitions) {
     throw new Error('You must specify a split greater than 0');
   }
 
-  const lintTestGroups = filterIntoGroups(modules, isLintTest, split);
-  const otherTestGroups = filterIntoGroups(modules, isNotLintTest, split);
+  const testGroups = splitIntoGroups(modules, split);
   const tests = [];
 
   for (let i = 0; i < partitions.length; i++) {
@@ -67,7 +57,7 @@ export default function splitTestModules(modules, split, partitions) {
     }
 
     const group = partition - 1;
-    tests.push(...lintTestGroups[group], ...otherTestGroups[group]);
+    tests.push(...testGroups[group]);
   }
 
   return tests;

addon-test-support/-private/weight-test-modules.js

@@ -1,15 +1,14 @@
 const TEST_TYPE_WEIGHT = {
-  eslint: 1,
   unit: 10,
   integration: 20,
   acceptance: 150,
 };
-const WEIGHT_REGEX = /\/(eslint|unit|integration|acceptance)\//;
+const WEIGHT_REGEX = /\/(unit|integration|acceptance)\//;
 const DEFAULT_WEIGHT = 50;
 
 /**
  * Return the weight for a given module name, a file path to the module
- * Ember tests consist of Acceptance, Integration, Unit, and lint tests. In general, acceptance takes
+ * Ember tests consist of Acceptance, Integration, and Unit tests. In general, acceptance takes
  * longest time to execute, followed by integration and unit.
  * The weight assigned to a module corresponds to its test type execution speed, with slowest being the highest in weight.
  * If the test type is not identifiable from the modulePath, weight default to 50 (ordered after acceptance, but before integration)

lib/commands/exam.js

@@ -41,7 +41,7 @@ module.exports = TestCommand.extend({
       type: Boolean,
       default: false,
       description:
-        'Load balance test modules. Test modules will be sorted by weight from slowest (acceptance) to fastest (eslint).',
+        'Load balance test modules. Test modules will be sorted by weight from slowest (acceptance) to fastest (unit).',
     },
     {
       name: 'preserve-test-name',

tests/dummy/app/templates/docs/load-balancing.md

@@ -4,7 +4,7 @@
 ember exam --parallel=<num> --load-balance
 ```
 
-The `load-balance` option allows you to load balance test files against multiple browsers. It will order the test files by test types, e.g. acceptance | integration | unit | eslint, and load balance the ordered test files between the browsers dynamically rather than statically.
+The `load-balance` option allows you to load balance test files against multiple browsers. It will order the test files by test types, e.g. acceptance | integration | unit, and load balance the ordered test files between the browsers dynamically rather than statically.
 **Note:** parallel must be used along with load-balance to specify a number of browser(s)
 
 The `load-balance` option was added to version 1.1 to address execution performance when running against a large test suite.

tests/unit/mocha/filter-test-modules-test.js

@@ -39,21 +39,16 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       beforeEach(() => {
         modules = [
           'foo-test',
-          'foo-test.jshint',
           'bar-test',
-          'bar-test.jshint',
         ];
       });
 
       afterEach(() => {
         modules = [];
       });
 
-      it('should return a list of jshint tests', () => {
-        expect(filterTestModules(modules, 'jshint')).to.deep.equal([
-          'foo-test.jshint',
-          'bar-test.jshint',
-        ]);
+      it('should return a list of filtered tests', () => {
+        expect(filterTestModules(modules, 'foo')).to.deep.equal(['foo-test']);
       });
 
       it('should return an empty list when there is no match', () => {
@@ -63,33 +58,22 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       });
 
       it('should return a list of tests matched with a regular expression', () => {
-        expect(filterTestModules(modules, '/jshint/')).to.deep.equal([
-          'foo-test.jshint',
-          'bar-test.jshint',
-        ]);
+        expect(filterTestModules(modules, '/foo/')).to.deep.equal(['foo-test']);
       });
 
-      it('should return a list of tests matched with a regular expression that excluses jshint', () => {
-        expect(filterTestModules(modules, '!/jshint/')).to.deep.equal([
-          'foo-test',
-          'bar-test',
-        ]);
+      it('should return a list of tests matched with a regular expression that excluses foo', () => {
+        expect(filterTestModules(modules, '!/foo/')).to.deep.equal(['bar-test']);
       });
 
       it('should return a list of tests matches with a list of string options', () => {
         expect(filterTestModules(modules, 'foo, bar')).to.deep.equal([
           'foo-test',
-          'foo-test.jshint',
           'bar-test',
-          'bar-test.jshint',
         ]);
       });
 
       it('should return a list of unique tests matches when options are repeated', () => {
-        expect(filterTestModules(modules, 'foo, foo')).to.deep.equal([
-          'foo-test',
-          'foo-test.jshint',
-        ]);
+        expect(filterTestModules(modules, 'foo, foo')).to.deep.equal(['foo-test']);
       });
     });
 

tests/unit/mocha/test-loader-test.js

@@ -19,13 +19,9 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
 
       window.requirejs.entries = {
         'test-1-test': true,
-        'test-1-test.jshint': true,
         'test-2-test': true,
-        'test-2-test.jshint': true,
         'test-3-test': true,
-        'test-3-test.jshint': true,
         'test-4-test': true,
-        'test-4-test.jshint': true,
       };
       this.originalURLParams = EmberExamTestLoader._urlParams;
     });
@@ -39,10 +35,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       testLoader.loadModules();
 
       expect(this.requiredModules).to.deep.equal([
-        'test-1-test.jshint',
-        'test-2-test.jshint',
-        'test-3-test.jshint',
-        'test-4-test.jshint',
         'test-1-test',
         'test-2-test',
         'test-3-test',
@@ -58,7 +50,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       testLoader.loadModules();
 
       expect(this.requiredModules).to.deep.equal([
-        'test-3-test.jshint',
         'test-3-test',
       ]);
     });
@@ -71,9 +62,7 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       testLoader.loadModules();
 
       expect(this.requiredModules).to.deep.equal([
-        'test-1-test.jshint',
         'test-1-test',
-        'test-3-test.jshint',
         'test-3-test',
       ]);
     });
@@ -86,7 +75,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       testLoader.loadModules();
 
       expect(this.requiredModules).to.deep.equal([
-        'test-1-test.jshint',
         'test-1-test',
       ]);
     });
@@ -99,7 +87,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       testLoader.loadModules();
 
       expect(this.requiredModules).to.deep.equal([
-        'test-3-test.jshint',
         'test-3-test',
       ]);
     });
@@ -178,38 +165,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
       }).to.throw(/You must specify partitions numbered greater than 0/);
     });
 
-    it('load works without lint tests', function () {
-      const testLoader = new EmberExamTestLoader(
-        this.testem,
-        new Map().set('nolint', true).set('partition', 4).set('split', 4)
-      );
-      testLoader.loadModules();
-
-      // ember-cli-mocha doesn't support disabling linting by url param
-      expect(this.requiredModules).to.deep.equal([
-        'test-4-test.jshint',
-        'test-4-test',
-      ]);
-    });
-
-    it('load works without non-lint tests', function () {
-      const testLoader = new EmberExamTestLoader(
-        this.testem,
-        new Map().set('partition', 4).set('split', 4)
-      );
-
-      window.requirejs.entries = {
-        'test-1-test.jshint': true,
-        'test-2-test.jshint': true,
-        'test-3-test.jshint': true,
-        'test-4-test.jshint': true,
-      };
-
-      testLoader.loadModules();
-
-      expect(this.requiredModules).to.deep.equal(['test-4-test.jshint']);
-    });
-
     it('load works with a double-digit single partition', function () {
       const testLoader = new EmberExamTestLoader(
         this.testem,

tests/unit/mocha/weight-test-modules-test.js

@@ -12,7 +12,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
   describe('Unit | Mocha | weight-test-modules', () => {
     it('should sort a list of file paths by weight', function () {
       const listOfModules = [
-        '/eslint/test-1-test',
         '/acceptance/test-1-test',
         '/unit/test-1-test',
         '/integration/test-1-test',
@@ -24,22 +23,19 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
         'test-1-test',
         '/integration/test-1-test',
         '/unit/test-1-test',
-        '/eslint/test-1-test',
       ]);
     });
 
     it('should sort a list of file paths by weight and alphbetical order', function () {
       const listOfModules = [
         'test-b-test',
         'test-a-test',
-        '/eslint/test-b-test',
         '/integration/test-b-test',
         '/integration/test-a-test',
         '/unit/test-b-test',
         '/acceptance/test-b-test',
         '/acceptance/test-a-test',
         '/unit/test-a-test',
-        '/eslint/test-a-test',
       ];
 
       expect(weightTestModules(listOfModules)).to.deep.equal([
@@ -51,8 +47,6 @@ if (macroCondition(dependencySatisfies('ember-mocha', '*'))) {
         '/integration/test-b-test',
         '/unit/test-a-test',
         '/unit/test-b-test',
-        '/eslint/test-a-test',
-        '/eslint/test-b-test',
       ]);
     });
   });

tests/unit/qunit/filter-test-modules-test.js

@@ -42,20 +42,18 @@ if (macroCondition(dependencySatisfies('ember-qunit', '*'))) {
         hooks.beforeEach(function () {
           this.modules = [
             'foo-test',
-            'foo-test.jshint',
             'bar-test',
-            'bar-test.jshint',
           ];
         });
 
         hooks.afterEach(function () {
           this.modules = [];
         });
 
-        test('should return a list of jshint tests', function (assert) {
+        test('should return a list of filtered tests', function (assert) {
           assert.deepEqual(
-            ['foo-test.jshint', 'bar-test.jshint'],
-            filterTestModules(this.modules, 'jshint')
+            ['foo-test'],
+            filterTestModules(this.modules, 'foo')
           );
         });
 
@@ -68,28 +66,28 @@ if (macroCondition(dependencySatisfies('ember-qunit', '*'))) {
 
         test('should return a list of tests matched with a regular expression', function (assert) {
           assert.deepEqual(
-            ['foo-test.jshint', 'bar-test.jshint'],
-            filterTestModules(this.modules, '/jshint/')
+            ['foo-test'],
+            filterTestModules(this.modules, '/foo/')
           );
         });
 
-        test('should return a list of tests matched with a regular expression that excluse jshint', function (assert) {
+        test('should return a list of tests matched with a regular expression that excluse foo', function (assert) {
           assert.deepEqual(
-            ['foo-test', 'bar-test'],
-            filterTestModules(this.modules, '!/jshint/')
+            ['bar-test'],
+            filterTestModules(this.modules, '!/foo/')
           );
         });
 
         test('should return a list of tests matches with a list of string options', function (assert) {
           assert.deepEqual(
-            ['foo-test', 'foo-test.jshint', 'bar-test', 'bar-test.jshint'],
+            ['foo-test', 'bar-test'],
             filterTestModules(this.modules, 'foo, bar')
           );
         });
 
         test('should return a list of unique tests matches when options are repeated', function (assert) {
           assert.deepEqual(
-            ['foo-test', 'foo-test.jshint'],
+            ['foo-test'],
             filterTestModules(this.modules, 'foo, foo')
           );
         });