Update order for assertion tests

Author: bwreid

Diff for: filter/core.spec.js

@@ -4,32 +4,43 @@ var assert = require('assert'),
 describe('Filter', function() {
   describe('#onlyEven()', function () {
     it('returns only those numbers that are even', function () {
-      var array = [10,15,20,25,30,35];
-      assert.deepEqual([10,20,30], core.onlyEven(array));
+      var input = [ 10, 15, 20, 25, 30, 35 ];
+      var expected = [ 10, 20, 30 ]
+      var actual = core.onlyEven(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#onlyOneWord()', function () {
     it('returns only those strings with a single word (no spaces)', function () {
-      var array = ['return', 'phrases', 'with one word'];
-      assert.deepEqual(['return', 'phrases'], core.onlyOneWord(array));
+      var input = [ 'return', 'phrases', 'with one word' ];
+      var expected = [ 'return', 'phrases' ]
+      var actual = core.onlyOneWord(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#positiveRowsOnly()', function () {
     it('return only the rows in the matrix that have all positive integers', function () {
-      var matrix = [[1, 10,-100],
-                    [2,-20, 200],
-                    [3, 30, 300]];
-      var result = [[3, 30, 300]];
-      assert.deepEqual(result, core.positiveRowsOnly(matrix));
+      var input = [[ 1, 10, -100 ],
+                   [ 2, -20, 200 ],
+                   [ 3, 30,  300 ]];
+      var expected = [[ 3, 30, 300 ]];
+      var actual = core.positiveRowsOnly(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#allSameVowels()', function () {
     it('return only those words where all the vowels are the same', function () {
-      var array = ['racecar', 'amalgam', 'oligopoly', 'zoom'];
-      assert.deepEqual(['amalgam', 'zoom'], core.allSameVowels(array));
+      var input = [ 'racecar', 'amalgam', 'oligopoly', 'zoom' ];
+      var expected = [ 'amalgam', 'zoom' ]
+      var actual = core.allSameVowels(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
-});
+});

Diff for: map/core.spec.js

@@ -4,34 +4,45 @@ var assert = require('assert'),
 describe('Map', function() {
   describe('#multiplyBy10()', function () {
     it('multiplies all elements in an array by 10', function () {
-      var array = [45, 1, -10, 11, 250];
-      assert.deepEqual([450, 10, -100, 110, 2500], core.multiplyBy10(array));
+      var input = [ 45, 1, -10, 11, 250 ]
+      var expected = [ 450, 10, -100, 110, 2500 ]
+      var actual = core.multiplyBy10(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#shiftRight()', function () {
     it('shifts items in an array to the right by one', function () {
-      var array = [{ name: '' }, 10, "left-side"];
-      assert.deepEqual(["left-side", { name: '' }, 10], core.shiftRight(array));
+      var input = [ { name: '' }, 10, 'left-side' ];
+      var expected = [ 'left-side', { name: '' }, 10 ]
+      var actual = core.shiftRight(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#onlyVowels()', function () {
     it('removes any non-vowel character from words in an array', function () {
-      var array = ['average', 'exceptional', 'amazing'];
-      assert.deepEqual(['aeae', 'eeioa', 'aai'], core.onlyVowels(array));
+      var input = [ 'average', 'exceptional', 'amazing' ];
+      var expected = [ 'aeae', 'eeioa', 'aai' ]
+      var actual = core.onlyVowels(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
 
   describe('#doubleMatrix()', function () {
     it('doubles the numbers in the matrix, maintaining the same structure', function () {
-      var matrix = [[1,2,3],
-                    [4,5,6],
-                    [7,8,9]];
-      var result = [[2,4,6],
-                    [8,10,12],
-                    [14,16,18]];
-      assert.deepEqual(result, core.doubleMatrix(matrix));
+      var input = [[ 1, 2,3 ],
+                   [ 4, 5,6 ],
+                   [ 7, 8,9 ]];
+      var expected = [[ 2, 4, 6],
+                      [ 8, 10, 12],
+                      [ 14, 16, 18]];
+      var actual = core.doubleMatrix(input)
+
+      assert.deepEqual(actual, expected);
     });
   });
-});
+});

Diff for: reduce/core.spec.js

@@ -4,37 +4,47 @@ var assert = require('assert'),
 describe('Reduce', function() {
   describe('#sum()', function () {
     it('sum all the numbers in the array', function () {
-      var array = [10,15,20,25,30,35];
-      assert.equal(135, core.sum(array));
+      var input = [ 10, 15, 20, 25, 30, 35 ];
+      var expected = 135
+      var actual = core.sum(input)
+
+      assert.equal(actual, expected);
     });
   });
 
   describe('#productAll()', function () {
     it('return the product of all items in the matrix', function () {
-      var matrix = [[1, 2, 3],
-                    [4, 5],
-                    [6]];
-      assert.equal(720, core.productAll(matrix));
+      var input = [[ 1, 2, 3 ],
+                   [ 4, 5 ],
+                   [ 6 ]];
+      var expected = 720
+      var actual = core.productAll(input)
+
+      assert.equal(actual, expected);
     });
   });
-  
+
   describe('#objectify()', function () {
     it('turns an array of arrays into an object', function () {
-      var matrix = [['Thundercats', '80s'],
-                    ['The Powerpuff Girls', '90s'],
-                    ['Sealab 2021', '00s']];
-      var result = { 'Thundercats': '80s',
-                     'The Powerpuff Girls': '90s',
-                     'Sealab 2021': '00s' };
-      assert.deepEqual(result, core.objectify(matrix));
+      var input = [[ 'Thundercats', '80s' ],
+                   [ 'The Powerpuff Girls', '90s' ],
+                   [ 'Sealab 2021', '00s' ]];
+      var expected = { 'Thundercats': '80s',
+                       'The Powerpuff Girls': '90s',
+                       'Sealab 2021': '00s' };
+      var actual = core.objectify(input)
+
+      assert.equal(actual, expected);
     });
   });
 
   describe('#luckyNumbers()', function () {
     it('return a fortune like sentence with lucky numbers', function () {
-      var array  = [30, 48, 11, 5, 32];
-      var result = 'Your lucky numbers are: 30, 48, 11, 5, and 32';
-      assert.equal(result, core.luckyNumbers(array));
+      var input  = [ 30, 48, 11, 5, 32 ];
+      var expected = 'Your lucky numbers are: 30, 48, 11, 5, and 32';
+      var actual = core.luckyNumbers(input)
+
+      assert.equal(actual, expected);
     });
   });
-});
+});