trackler 2.1.0.53 → 2.1.0.54

data/tracks/ecmascript/exercises/pig-latin/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/pig-latin/pig-latin.spec.js

@@ -3,47 +3,47 @@ import PigLatin from './pig-latin';
 describe('Pig Latin', () => {
   const translator = new PigLatin();
 
-  it('translates a word beginning with a', () => {
+  test('translates a word beginning with a', () => {
     expect(translator.translate('apple')).toEqual('appleay');
   });
 
-  xit('translates a word beginning with e', () => {
+  xtest('translates a word beginning with e', () => {
     expect(translator.translate('ear')).toEqual('earay');
   });
 
-  xit('translates a word beginning with p', () => {
+  xtest('translates a word beginning with p', () => {
     expect(translator.translate('pig')).toEqual('igpay');
   });
 
-  xit('translates a word beginning with k', () => {
+  xtest('translates a word beginning with k', () => {
     expect(translator.translate('koala')).toEqual('oalakay');
   });
 
-  xit('translates a word beginning with ch', () => {
+  xtest('translates a word beginning with ch', () => {
     expect(translator.translate('chair')).toEqual('airchay');
   });
 
-  xit('translates a word beginning with qu', () => {
+  xtest('translates a word beginning with qu', () => {
     expect(translator.translate('queen')).toEqual('eenquay');
   });
 
-  xit('translates a word with a consonant preceding qu', () => {
+  xtest('translates a word with a consonant preceding qu', () => {
     expect(translator.translate('square')).toEqual('aresquay');
   });
 
-  xit('translates a word beginning with th', () => {
+  xtest('translates a word beginning with th', () => {
     expect(translator.translate('therapy')).toEqual('erapythay');
   });
 
-  xit('translates a word beginning with thr', () => {
+  xtest('translates a word beginning with thr', () => {
     expect(translator.translate('thrush')).toEqual('ushthray');
   });
 
-  xit('translates a word beginning with sch', () => {
+  xtest('translates a word beginning with sch', () => {
     expect(translator.translate('school')).toEqual('oolschay');
   });
 
-  xit('translates a phrase', () => {
+  xtest('translates a phrase', () => {
     expect(translator.translate('quick fast run'))
       .toEqual('ickquay astfay unray');
   });

data/tracks/ecmascript/exercises/prime-factors/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/prime-factors/prime-factors.spec.js

@@ -3,26 +3,26 @@ const primeFactors = new PrimeFactors();
 
 describe('primeFactors', () => {
 
-  it('returns an empty array for 1', () => expect(primeFactors.for(1)).toEqual([]));
+  test('returns an empty array for 1', () => expect(primeFactors.for(1)).toEqual([]));
 
-  xit('factors 2', () => expect(primeFactors.for(2)).toEqual([2]));
+  xtest('factors 2', () => expect(primeFactors.for(2)).toEqual([2]));
 
-  xit('factors 3', () => expect(primeFactors.for(3)).toEqual([3]));
+  xtest('factors 3', () => expect(primeFactors.for(3)).toEqual([3]));
 
-  xit('factors 4', () => expect(primeFactors.for(4)).toEqual([2, 2]));
+  xtest('factors 4', () => expect(primeFactors.for(4)).toEqual([2, 2]));
 
-  xit('factors 6', () => expect(primeFactors.for(6)).toEqual([2, 3]));
+  xtest('factors 6', () => expect(primeFactors.for(6)).toEqual([2, 3]));
 
-  xit('factors 8', () => expect(primeFactors.for(8)).toEqual([2, 2, 2]));
+  xtest('factors 8', () => expect(primeFactors.for(8)).toEqual([2, 2, 2]));
 
-  xit('factors 9', () => expect(primeFactors.for(9)).toEqual([3, 3]));
+  xtest('factors 9', () => expect(primeFactors.for(9)).toEqual([3, 3]));
 
-  xit('factors 27', () => expect(primeFactors.for(27)).toEqual([3, 3, 3]));
+  xtest('factors 27', () => expect(primeFactors.for(27)).toEqual([3, 3, 3]));
 
-  xit('factors 625', () => expect(primeFactors.for(625)).toEqual([5, 5, 5, 5]));
+  xtest('factors 625', () => expect(primeFactors.for(625)).toEqual([5, 5, 5, 5]));
 
-  xit('factors 901255', () => expect(primeFactors.for(901255)).toEqual([5, 17, 23, 461]));
+  xtest('factors 901255', () => expect(primeFactors.for(901255)).toEqual([5, 17, 23, 461]));
 
-  xit('factors 93819012551', () => expect(primeFactors.for(93819012551)).toEqual([11, 9539, 894119]));
+  xtest('factors 93819012551', () => expect(primeFactors.for(93819012551)).toEqual([11, 9539, 894119]));
 
 });

data/tracks/ecmascript/exercises/pythagorean-triplet/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/pythagorean-triplet/pythagorean-triplet.spec.js

@@ -2,23 +2,23 @@ import Triplet from './pythagorean-triplet';
 
 describe('Triplet', () => {
 
-  it('calculates the sum', () => {
+  test('calculates the sum', () => {
     expect(new Triplet(3, 4, 5).sum()).toBe(12);
   });
 
-  xit('calculates the product', () => {
+  xtest('calculates the product', () => {
     expect(new Triplet(3, 4, 5).product()).toBe(60);
   });
 
-  xit('can recognize a pythagorean triplet', () => {
+  xtest('can recognize a pythagorean triplet', () => {
     expect(new Triplet(3, 4, 5).isPythagorean()).toBe(true);
   });
 
-  xit('can recognize a non pythagorean triplet', () => {
+  xtest('can recognize a non pythagorean triplet', () => {
     expect(new Triplet(5, 6, 7).isPythagorean()).toBe(false);
   });
 
-  xit('can make triplets up to 10', () => {
+  xtest('can make triplets up to 10', () => {
     const triplets = Triplet.where({ maxFactor: 10 });
     const products = triplets.sort().map(triplet => {
       return triplet.product();
@@ -26,7 +26,7 @@ describe('Triplet', () => {
     expect(products).toEqual([60, 480]);
   });
 
-  xit('can make triplets 11 through 20', () => {
+  xtest('can make triplets 11 through 20', () => {
     const triplets = Triplet.where({ minFactor: 11, maxFactor: 20 });
     const products = triplets.sort().map(triplet => {
       return triplet.product();
@@ -34,7 +34,7 @@ describe('Triplet', () => {
     expect(products).toEqual([3840]);
   });
 
-  xit('can filter on sum', () => {
+  xtest('can filter on sum', () => {
     const triplets = Triplet.where({ sum: 180, maxFactor: 100 });
     const products = triplets.sort().map(triplet => {
       return triplet.product();

data/tracks/ecmascript/exercises/queen-attack/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/queen-attack/queen-attack.spec.js

@@ -1,19 +1,19 @@
 import Queens from './queen-attack';
 
 describe('Queens', () => {
-  it('has the correct default positions', () => {
+  test('has the correct default positions', () => {
     const queens = new Queens();
     expect(queens.white).toEqual([0, 3]);
     expect(queens.black).toEqual([7, 3]);
   });
 
-  xit('initialized with specific placement', () => {
+  xtest('initialized with specific placement', () => {
     const queens = new Queens({white: [3,7], black: [6,1]});
     expect(queens.white).toEqual([3, 7]);
     expect(queens.black).toEqual([6, 1]);
   });
 
-  xit('cannot occupy the same space', () => {
+  xtest('cannot occupy the same space', () => {
     const positioning = {white: [2,4], black: [2,4]};
 
     try {
@@ -23,7 +23,7 @@ describe('Queens', () => {
     }
   });
 
-  xit('toString representation', () => {
+  xtest('toString representation', () => {
     const positioning = {white: [2, 4], black: [6, 6]};
     const queens = new Queens(positioning);
     const board = '_ _ _ _ _ _ _ _\n\
@@ -38,42 +38,42 @@ _ _ _ _ _ _ _ _\n\
     expect(queens.toString()).toEqual(board);
   });
 
-  xit('queens cannot attack', () => {
+  xtest('queens cannot attack', () => {
     const queens = new Queens({ white: [2,3], black: [4,7] });
     expect(queens.canAttack()).toEqual(false);
   });
 
-  xit('queens can attack when they are on the same row', () => {
+  xtest('queens can attack when they are on the same row', () => {
     const queens = new Queens({ white: [2,4], black: [2,7] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack when they are on the same column', () => {
+  xtest('queens can attack when they are on the same column', () => {
     const queens = new Queens({ white: [5,4], black: [2,4] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack diagonally', () => {
+  xtest('queens can attack diagonally', () => {
     const queens = new Queens({ white: [1, 1], black: [6, 6] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack another diagonally', () => {
+  xtest('queens can attack another diagonally', () => {
     const queens = new Queens({ white: [0, 6], black: [1, 7] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack yet another diagonally', () => {
+  xtest('queens can attack yet another diagonally', () => {
     const queens = new Queens({ white: [4, 1], black: [6, 3] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack on a north-east/south-west diagonal', () => {
+  xtest('queens can attack on a north-east/south-west diagonal', () => {
     const queens = new Queens({ white: [7, 0], black: [0, 7] });
     expect(queens.canAttack()).toEqual(true);
   });
 
-  xit('queens can attack on another ne/sw diagonal', () => {
+  xtest('queens can attack on another ne/sw diagonal', () => {
     const queens = new Queens({ white: [2, 6], black: [5, 3] });
     expect(queens.canAttack()).toEqual(true);
   });

data/tracks/ecmascript/exercises/raindrops/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/raindrops/raindrops.spec.js

@@ -3,36 +3,36 @@ import Raindrops from './raindrops';
 describe('Raindrops', ()  => {
   const drops = new Raindrops();
 
-  it('converts 1', () => expect(drops.convert(1)).toEqual('1'));
+  test('converts 1', () => expect(drops.convert(1)).toEqual('1'));
 
-  xit('converts 3', () => expect(drops.convert(3)).toEqual('Pling'));
+  xtest('converts 3', () => expect(drops.convert(3)).toEqual('Pling'));
 
-  xit('converts 5', () => expect(drops.convert(5)).toEqual('Plang'));
+  xtest('converts 5', () => expect(drops.convert(5)).toEqual('Plang'));
 
-  xit('converts 7', () => expect(drops.convert(7)).toEqual('Plong'));
+  xtest('converts 7', () => expect(drops.convert(7)).toEqual('Plong'));
 
-  xit('converts 6', () => expect(drops.convert(6)).toEqual('Pling'));
+  xtest('converts 6', () => expect(drops.convert(6)).toEqual('Pling'));
 
-  xit('converts 9', () => expect(drops.convert(9)).toEqual('Pling'));
+  xtest('converts 9', () => expect(drops.convert(9)).toEqual('Pling'));
 
-  xit('converts 10', () => expect(drops.convert(10)).toEqual('Plang'));
+  xtest('converts 10', () => expect(drops.convert(10)).toEqual('Plang'));
 
-  xit('converts 14', () => expect(drops.convert(14)).toEqual('Plong'));
+  xtest('converts 14', () => expect(drops.convert(14)).toEqual('Plong'));
 
-  xit('converts 15', () => expect(drops.convert(15)).toEqual('PlingPlang'));
+  xtest('converts 15', () => expect(drops.convert(15)).toEqual('PlingPlang'));
 
-  xit('converts 21', () => expect(drops.convert(21)).toEqual('PlingPlong'));
+  xtest('converts 21', () => expect(drops.convert(21)).toEqual('PlingPlong'));
 
-  xit('converts 25', () => expect(drops.convert(25)).toEqual('Plang'));
+  xtest('converts 25', () => expect(drops.convert(25)).toEqual('Plang'));
 
-  xit('converts 35', () => expect(drops.convert(35)).toEqual('PlangPlong'));
+  xtest('converts 35', () => expect(drops.convert(35)).toEqual('PlangPlong'));
 
-  xit('converts 49', () => expect(drops.convert(49)).toEqual('Plong'));
+  xtest('converts 49', () => expect(drops.convert(49)).toEqual('Plong'));
 
-  xit('converts 52', () => expect(drops.convert(52)).toEqual('52'));
+  xtest('converts 52', () => expect(drops.convert(52)).toEqual('52'));
 
-  xit('converts 105', () => expect(drops.convert(105)).toEqual('PlingPlangPlong'));
+  xtest('converts 105', () => expect(drops.convert(105)).toEqual('PlingPlangPlong'));
 
-  xit('converts 12121', () => expect(drops.convert(12121)).toEqual('12121'));
+  xtest('converts 12121', () => expect(drops.convert(12121)).toEqual('12121'));
 
 });

data/tracks/ecmascript/exercises/rna-transcription/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {

data/tracks/ecmascript/exercises/rna-transcription/rna-transcription.spec.js

@@ -3,40 +3,40 @@ import Transcriptor from './rna-transcription';
 describe('Transcriptor', () => {
   let transcriptor = new Transcriptor();
 
-  it('transcribes cytosine to guanine', () => {
+  test('transcribes cytosine to guanine', () => {
     expect(transcriptor.toRna('C')).toEqual('G');
   });
 
-  xit('transcribes guanine to cytosine', () => {
+  xtest('transcribes guanine to cytosine', () => {
     expect(transcriptor.toRna('G')).toEqual('C');
   });
 
-  xit('transcribes adenine to uracil', () => {
+  xtest('transcribes adenine to uracil', () => {
     expect(transcriptor.toRna('A')).toEqual('U');
   });
 
-  xit('transcribes thymine to adenine', () => {
+  xtest('transcribes thymine to adenine', () => {
     expect(transcriptor.toRna('T')).toEqual('A');
   });
 
-  xit('transcribes all dna nucleotides to their rna complements', () => {
+  xtest('transcribes all dna nucleotides to their rna complements', () => {
     expect(transcriptor.toRna('ACGTGGTCTTAA'))
         .toEqual('UGCACCAGAAUU');
   });
 
-  xit('correctly handles invalid input', () => {
+  xtest('correctly handles invalid input', () => {
     expect(() => transcriptor.toRna('U')).toThrow(
       new Error('Invalid input DNA.')
     );
   });
 
-  xit('correctly handles completely invalid input', () => {
+  xtest('correctly handles completely invalid input', () => {
     expect(() => transcriptor.toRna('XXX')).toThrow(
       new Error('Invalid input DNA.')
     );
   });
 
-  xit('correctly handles partially invalid input', () => {
+  xtest('correctly handles partially invalid input', () => {
     expect(() => transcriptor.toRna('ACGTXXXCTTAA')).toThrow(
       new Error('Invalid input DNA.')
     );

data/tracks/ecmascript/exercises/robot-name/package.json

@@ -25,9 +25,14 @@
       "env"
     ],
     "plugins": [
-      ["babel-plugin-transform-builtin-extend", {
-        "globals": ["Error"]
-      }]
+      [
+        "babel-plugin-transform-builtin-extend",
+        {
+          "globals": [
+            "Error"
+          ]
+        }
+      ]
     ]
   },
   "scripts": {