Rewrite get-card-value test in Jest, fix the Node test, modify the implementation

Author: ausiejute

implement-and-rewrite-tests/implement-tests-with-node-test/3-get-card-value.test.js

@@ -5,28 +5,64 @@ import { getCardValue } from "../implement/3-get-card-value.js";
 
 // TODO: Write tests to cover all outcomes, including throwing errors for invalid cards.
 
+// test("Valid single-digit card", () => {
+//   assert.equal(getCardValue("9♠"), 9);
+// });
+
+// test("Arbitrary non-card string", () => {
+//   assert.throws(
+//     () => getCardValue("invalid"),
+//     /Expected a number followed by a suit, but got "invalid"/
+//   );
+// });
+
 test("Valid single-digit card", () => {
-  assert.equal(getCardValue("9♠"), 9);
+  assert.equal(getCardValue("2♠"), 2);
 });
-
-test("Arbitrary non-card string", () => {
-  assert.throws(
-    () => getCardValue("invalid"),
-    /Expected a number followed by a suit, but got "invalid"/,
-    "Expected clear error"
-  );
+test("Valid double-digit card", () => {
+  assert.equal(getCardValue("10♥"), 10);
+});
+test("Valid king card", () => {
+  assert.equal(getCardValue("Q♣"), 10);
+});
+test("Valid queen card", () => {
+  assert.equal(getCardValue("K♠"), 10);
+});
+test("Valid jack card", () => {
+  assert.equal(getCardValue("J♦"), 10);
+});
+test("Valid ace card", () => {
+  assert.equal(getCardValue("A♠"), 11);
 });
 
 // TODO: What other invalid card cases can you think of?
 
-test("Valid double digit card", () => {
-  assert.equal(getCardValue("10♠"), 10);
-});
-
 test("No suit symbol", () => {
   assert.throws(
     () => getCardValue("A"),
     Error,
     "Should throw an error for card without suit"
   );
 });
+
+test("Invalid number", () => {
+  assert.throws(
+    () => getCardValue("0"),
+    Error,
+    "Should throw an error for card with invalid number"
+  );
+});
+test("Empty input", () => {
+  assert.throws(
+    () => getCardValue(""),
+    Error,
+    "Should throw an error for empty input"
+  );
+});
+test("Any other invalid input", () => {
+  assert.throws(
+    () => getCardValue("10♥♥"),
+    Error,
+    "Should throw an error for an invalid input"
+  );
+});

implement-and-rewrite-tests/implement/3-get-card-value.js

@@ -24,15 +24,14 @@
 // execute the code to ensure all tests pass.
 
 function getCardValue(card) {
+  if (card == "") {
+    throw new Error(`Missing a specific number and specific suit symbol`);
+  }
   const cardRank = card.slice(0, -1);
   const suit = card.slice(-1);
 
-  if (cardRank === card) {
-    throw new Error(`Expected a number followed by a suit, but got "${card}"`);
-  }
-
   if (!["♠", "♥", "♦", "♣"].includes(suit)) {
-    throw new Error(`Expected a number followed by a suit, but got "${card}"`);
+    throw new Error(`Missing a specific suit symbol`);
   }
 
   if (cardRank == "A") {
@@ -54,7 +53,7 @@ function getCardValue(card) {
   ) {
     return Number(cardRank);
   } else {
-    throw new Error(`Expected a number followed by a suit, but got "${card}"`);
+    throw new Error(`Missing a specific number and specific suit symbol`);
   }
 }
 

implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js

@@ -15,4 +15,64 @@ test(`Should return 11 when given an ace card`, () => {
 // To learn how to test whether a function throws an error as expected in Jest,
 // please refer to the Jest documentation:
 // https://jestjs.io/docs/expect#tothrowerror
+// -----number cards------
+test(`Should return 2 when given a 2 card`, () => {
+  expect(getCardValue("2♥")).toEqual(2);
+});
 
+test(`Should return 3 when given a 3 card`, () => {
+  expect(getCardValue("3♣")).toEqual(3);
+});
+test(`Should return 4 when given a 4 card`, () => {
+  expect(getCardValue("4♦")).toEqual(4);
+});
+test(`Should return 5 when given a 5 card`, () => {
+  expect(getCardValue("5♠")).toEqual(5);
+});
+test(`Should return 6 when given a 6 card`, () => {
+  expect(getCardValue("6♦")).toEqual(6);
+});
+test(`Should return 7 when given a 7 card`, () => {
+  expect(getCardValue("7♥")).toEqual(7);
+});
+test(`Should return 8 when given a 8 card`, () => {
+  expect(getCardValue("8♠")).toEqual(8);
+});
+test(`Should return 9 when given a 9 card`, () => {
+  expect(getCardValue("9♥")).toEqual(9);
+});
+test(`Should return 10 when given a 10 card`, () => {
+  expect(getCardValue("10♣")).toEqual(10);
+});
+// -----remaining face cards-----
+test(`Should return 10 when given a jack card`, () => {
+  expect(getCardValue("J♥")).toEqual(10);
+});
+test(`Should return 10 when given a king card`, () => {
+  expect(getCardValue("K♣")).toEqual(10);
+});
+test(`Should return 10 when given a queen card`, () => {
+  expect(getCardValue("Q♥")).toEqual(10);
+});
+// -----invalid cards-----
+test("Should throw an error for card without suit", () => {
+  expect(() => getCardValue("A")).toThrow("Missing a specific suit symbol");
+});
+
+test("Should throw an error for card with invalid number", () => {
+  expect(() => getCardValue("0♥")).toThrow(
+    "Missing a specific number and specific suit symbol"
+  );
+});
+
+test("Should throw an error for empty input", () => {
+  expect(() => getCardValue("")).toThrow(
+    "Missing a specific number and specific suit symbol"
+  );
+});
+
+test("Should throw an error for an invalid input", () => {
+  expect(() => getCardValue("J♥♥")).toThrow(
+    "Missing a specific number and specific suit symbol"
+  );
+});