Merge pull request Ada-C12#29 from AdaGold/be/update-tests

Be/update tests

Author: beccaelenzil

README.md

@@ -16,6 +16,8 @@ In this project, we will build the same Adagrams project from the Python curricu
 
 A test suite and sample game project is provided in order to practice TDD and verify the correct implementation. A complete project will pass all of the provided tests and have coverage of at least 90%.
 
+Note there are a handful of incomplete tests that currently throw exceptions. You should complete these tests and remove the exception.
+
 ## Getting Started
 
 After forking and cloning this repo you should `cd` to the project directory and run:

src/adagrams.js

@@ -1,8 +1,15 @@
-const Adagrams = {
-  drawLetters() {
-    // Implement this method for wave 1
-  },
+export const drawLetters = () => {
+  // Implement this method for wave 1
 };
 
-// Do not remove this line or your tests will break!
-export default Adagrams;
+export const usesAvailableLetters = (input, lettersInHand) => {
+  // Implement this method for wave 2
+};
+
+export const scoreWord = (word) => {
+  // Implement this method for wave 3
+};
+
+export const highestScoreFrom = (words) => {
+  // Implement this method for wave 1
+};

src/demo/adagrams.js

@@ -1,38 +1,50 @@
-import Real from 'adagrams';
+import {
+  drawLetters,
+  usesAvailableLetters,
+  scoreWord,
+  highestScoreFrom,
+} from "adagrams";
+
+const Real = {
+  drawLetters,
+  usesAvailableLetters,
+  scoreWord,
+  highestScoreFrom,
+};
 
 const Stub = {
   drawLetters() {
-    const defaultLetters = ['H', 'E', 'L', 'L', 'O', 'W', 'O', 'R', 'L', 'D'];
+    const defaultLetters = ["H", "E", "L", "L", "O", "W", "O", "R", "L", "D"];
 
-    if(typeof Real.drawLetters === 'function') {
+    if (typeof Real.drawLetters === "function") {
       return Real.drawLetters() || defaultLetters;
     }
 
     return defaultLetters;
   },
 
   usesAvailableLetters(input, lettersInHand) {
-    if(typeof Real.usesAvailableLetters === 'function') {
+    if (typeof Real.usesAvailableLetters === "function") {
       return Real.usesAvailableLetters(input, lettersInHand);
     }
 
     return true;
   },
 
   scoreWord(word) {
-    if(typeof Real.scoreWord === 'function') {
+    if (typeof Real.scoreWord === "function") {
       return Real.scoreWord(word);
     }
 
     return -1;
   },
 
   highestScoreFrom(words) {
-    if(typeof Real.highestScoreFrom === 'function') {
+    if (typeof Real.highestScoreFrom === "function") {
       return Real.highestScoreFrom(words);
     }
 
-    if(words.length < 1) return null;
+    if (words.length < 1) return null;
 
     return {
       word: words[0],

test/adagrams.test.js

@@ -1,80 +1,129 @@
-import Adagrams from 'adagrams';
-
-describe('Adagrams', () => {
-  describe('drawLetters', () => {
-    it('draws ten letters from the letter pool', () => {
-      const drawn = Adagrams.drawLetters();
+import {
+  drawLetters,
+  usesAvailableLetters,
+  scoreWord,
+  highestScoreFrom,
+} from "adagrams";
+
+const LETTER_POOL = {
+  A: 9,
+  B: 2,
+  C: 2,
+  D: 4,
+  E: 12,
+  F: 2,
+  G: 3,
+  H: 2,
+  I: 9,
+  J: 1,
+  K: 1,
+  L: 4,
+  M: 2,
+  N: 6,
+  O: 8,
+  P: 2,
+  Q: 1,
+  R: 6,
+  S: 4,
+  T: 6,
+  U: 4,
+  V: 2,
+  W: 2,
+  X: 1,
+  Y: 2,
+  Z: 1,
+};
+
+describe("Adagrams", () => {
+  describe("drawLetters", () => {
+    it("draws ten letters from the letter pool", () => {
+      const drawn = drawLetters();
 
       expect(drawn).toHaveLength(10);
     });
 
-    it('returns an array, and each item is a single-letter string', () => {
-      const drawn = Adagrams.drawLetters();
+    it("returns an array, and each item is a single-letter string", () => {
+      const drawn = drawLetters();
 
       expect(Array.isArray(drawn)).toBe(true);
       drawn.forEach((l) => {
         expect(l).toMatch(/^[A-Z]$/);
       });
     });
+
+    it("does not draw a letter too many times", () => {
+      for (let i = 0; i < 1000; i++) {
+        const drawn = drawLetters();
+        const letter_freq = {};
+        for (let letter of drawn) {
+          if (letter in letter_freq) {
+            letter_freq[letter] += 1;
+          } else {
+            letter_freq[letter] = 1;
+          }
+        }
+
+        for (let letter of drawn) {
+          expect(letter_freq[letter]).toBeLessThanOrEqual(LETTER_POOL[letter]);
+        }
+      }
+    });
   });
 
-  describe('usesAvailableLetters', () => {
-    it('returns true if the submitted letters are valid against the drawn letters', () => {
-      const drawn = ['D', 'O', 'G', 'X', 'X', 'X', 'X', 'X', 'X', 'X'];
-      const word = 'DOG';
+  describe("usesAvailableLetters", () => {
+    it("returns true if the submitted letters are valid against the drawn letters", () => {
+      const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"];
+      const word = "DOG";
 
-      const isValid = Adagrams.usesAvailableLetters(word, drawn);
+      const isValid = usesAvailableLetters(word, drawn);
       expect(isValid).toBe(true);
     });
 
-    it('returns false when word contains letters not in the drawn letters', () => {
-      const drawn = ['D', 'O', 'X', 'X', 'X', 'X', 'X', 'X', 'X', 'X'];
-      const word = 'DOG';
+    it("returns false when word contains letters not in the drawn letters", () => {
+      const drawn = ["D", "O", "X", "X", "X", "X", "X", "X", "X", "X"];
+      const word = "DOG";
 
-      const isValid = Adagrams.usesAvailableLetters(word, drawn);
+      const isValid = usesAvailableLetters(word, drawn);
       expect(isValid).toBe(false);
     });
 
-    it('returns false when word contains repeated letters more than in the drawn letters', () => {
-      const drawn = ['D', 'O', 'G', 'X', 'X', 'X', 'X', 'X', 'X', 'X'];
-      const word = 'GOOD';
+    it("returns false when word contains repeated letters more than in the drawn letters", () => {
+      const drawn = ["D", "O", "G", "X", "X", "X", "X", "X", "X", "X"];
+      const word = "GOOD";
 
-      const isValid = Adagrams.usesAvailableLetters(word, drawn);
+      const isValid = usesAvailableLetters(word, drawn);
       expect(isValid).toBe(false);
-
     });
   });
 
-  describe('scoreWord', () => {
+  describe("scoreWord", () => {
     const expectScores = (wordScores) => {
       Object.entries(wordScores).forEach(([word, score]) => {
-        expect(Adagrams.scoreWord(word)).toBe(score);
+        expect(scoreWord(word)).toBe(score);
       });
     };
 
-    it('returns an accurate numerical score according to the score chart', () => {
+    it("returns an accurate numerical score according to the score chart", () => {
       expectScores({
         A: 1,
         DOG: 5,
-        WHIMSY: 17
+        WHIMSY: 17,
       });
     });
 
-    it('returns a score regardless of the input case', () => {
+    it("returns a score regardless of the input case", () => {
       expectScores({
         a: 1,
         dog: 5,
-        wHiMsY: 17
+        wHiMsY: 17,
       });
     });
 
-    it('returns a score of 0 if given an empty input', () => {
-      expectScores({
-        '': 0
-      });
+    it("returns a score of 0 if given an empty input", () => {
+      throw "Complete test";
     });
 
-    it('adds an extra 8 points if word is 7 or more characters long', () => {
+    it("adds an extra 8 points if word is 7 or more characters long", () => {
       expectScores({
         XXXXXXX: 64,
         XXXXXXXX: 72,
@@ -84,57 +133,66 @@ describe('Adagrams', () => {
     });
   });
 
-  describe.skip('highestScoreFrom', () => {
-    it('returns a hash that contains the word and score of best word in an array', () => {
-      const words = ['X', 'XX', 'XXX', 'XXXX'];
-      const correct = { word: 'XXXX', score: Adagrams.scoreWord('XXXX') };
+  describe("highestScoreFrom", () => {
+    it("returns a hash that contains the word and score of best word in an array", () => {
+      const words = ["X", "XX", "XXX", "XXXX"];
+      const correct = { word: "XXXX", score: scoreWord("XXXX") };
 
-      expect(Adagrams.highestScoreFrom(words)).toEqual(correct);
+      expect(highestScoreFrom(words)).toEqual(correct);
     });
 
-    it('accurately finds best scoring word even if not sorted', () => {
-      const words = ['XXX', 'XXXX', 'X', 'XX'];
-      const correct = { word: 'XXXX', score: Adagrams.scoreWord('XXXX') };
+    it("accurately finds best scoring word even if not sorted", () => {
+      const words = ["XXX", "XXXX", "X", "XX"];
+      const correct = { word: "XXXX", score: scoreWord("XXXX") };
 
-      expect(Adagrams.highestScoreFrom(words)).toEqual(correct);
+      throw "Complete test by adding an assertion";
     });
 
-    describe('in case of tied score', () => {
+    describe("in case of tied score", () => {
       const expectTie = (words) => {
-        const scores = words.map(word => Adagrams.scoreWord(word));
-        const highScore = scores.reduce((h, s) => h < s ? s : h, 0);
+        const scores = words.map((word) => scoreWord(word));
+        const highScore = scores.reduce((h, s) => (h < s ? s : h), 0);
         const tiedWords = scores.filter((s) => s == highScore);
 
         // Expect at least two tied words
         expect(tiedWords.length).toBeGreaterThan(1);
       };
 
-      it('selects the word with 10 letters', () => {
-        const words = ['AAAAAAAAAA', 'BBBBBB'];
-        const correct = { word: 'AAAAAAAAAA', score: Adagrams.scoreWord('AAAAAAAAAA') };
+      it("selects the word with 10 letters", () => {
+        const words = ["AAAAAAAAAA", "BBBBBB"];
+        const correct = {
+          word: "AAAAAAAAAA",
+          score: scoreWord("AAAAAAAAAA"),
+        };
         expectTie(words);
 
-        expect(Adagrams.highestScoreFrom(words)).toEqual(correct);
-        expect(Adagrams.highestScoreFrom(words.reverse())).toEqual(correct);
+        expect(highestScoreFrom(words)).toEqual(correct);
+        expect(highestScoreFrom(words.reverse())).toEqual(correct);
       });
 
-      it('selects the word with fewer letters when neither are 10 letters', () => {
-        const words = ['MMMM', 'WWW'];
-        const correct = { word: 'WWW', score: Adagrams.scoreWord('WWW') };
+      it("selects the word with fewer letters when neither are 10 letters", () => {
+        const words = ["MMMM", "WWW"];
+        const correct = { word: "WWW", score: scoreWord("WWW") };
         expectTie(words);
 
-        expect(Adagrams.highestScoreFrom(words)).toEqual(correct);
-        expect(Adagrams.highestScoreFrom(words.reverse())).toEqual(correct);
+        expect(highestScoreFrom(words)).toEqual(correct);
+        expect(highestScoreFrom(words.reverse())).toEqual(correct);
       });
 
-      it('selects the first word when both have same length', () => {
-        const words = ['AAAAAAAAAA', 'EEEEEEEEEE'];
-        const first = { word: 'AAAAAAAAAA', score: Adagrams.scoreWord('AAAAAAAAAA') };
-        const second = { word: 'EEEEEEEEEE', score: Adagrams.scoreWord('EEEEEEEEEE') };
+      it("selects the first word when both have same length", () => {
+        const words = ["AAAAAAAAAA", "EEEEEEEEEE"];
+        const first = {
+          word: "AAAAAAAAAA",
+          score: scoreWord("AAAAAAAAAA"),
+        };
+        const second = {
+          word: "EEEEEEEEEE",
+          score: scoreWord("EEEEEEEEEE"),
+        };
         expectTie(words);
 
-        expect(Adagrams.highestScoreFrom(words)).toEqual(first);
-        expect(Adagrams.highestScoreFrom(words.reverse())).toEqual(second);
+        expect(highestScoreFrom(words)).toEqual(first);
+        expect(highestScoreFrom(words.reverse())).toEqual(second);
       });
     });
   });