London |26-ITP-Sep| Maharit Belai| Sprint 2 | Implement and rewrite tests

implement-and-rewrite-tests/implement-tests-with-node-test/1-get-angle-type.test.js

@@ -10,3 +10,31 @@ test("Classifies right angles", () => {
   const right = getAngleType(90);
   assert.equal(right, "Right angle");
 });
+test("Classifies obtuse angles", () => {
+  const obtuse = getAngleType(91);
+  assert.equal(obtuse, "Obtuse angle");
+});
+test("Classifies acute angle", () => {
+  const acute = getAngleType(75);
+  assert.equal(acute, "Acute angle");
+});
+test("Classifies straight angle", () => {
+  const straight = getAngleType(180);
+  assert.equal(straight, "Straight angle");
+});
+test("Classifies reflex angle", () => {
+  const reflex = getAngleType(270);
+  assert.equal(reflex, "Reflex angle");
+});
+test("Classifiesreflex angle", () => {
+  const invalid = getAngleType(0);
+  assert.equal(invalid, "Invalid angle");
+});
+test("Classifiesreflex angle", () => {
+  const invalid = getAngleType(-90);
+  assert.equal(invalid, "Invalid angle");
+});
+test("Classifiesreflex angle", () => {
+  const invalid = getAngleType(360);
+  assert.equal(invalid, "Invalid angle");
+});

implement-and-rewrite-tests/implement-tests-with-node-test/2-is-proper-fraction.test.js

@@ -10,3 +10,33 @@ test("Basic proper fraction", () => {
   // Example: 1/2 is a proper fraction
   assert.equal(isProperFraction(1, 2), true);
 });
+test("checking when numerator < denominators", () => {
+  assert.equal(isProperFraction(2, 4), true);
+});
+test("checking when Numerator > denominator", () => {
+  assert.equal(isProperFraction(4, 1), false);
+  assert.equal(isProperFraction(5, 2), false);
+});
+test("checking when numerator = denominator ", () => {
+  assert.equal(isProperFraction(1, 1), false);
+  assert.equal(isProperFraction(2, 2), false);
+});
+test("Checking when numerator is negative number", () => {
+  assert.equal(isProperFraction(-1, 2), true);
+  assert.equal(isProperFraction(-4, -6), true);
+});
+test("checking when denominator is negtive number", () => {
+  assert.equal(isProperFraction(1, -2), true);
+  assert.equal(isProperFraction(2, -8), true);
+});
+test("checking when denominator = 0", () => {
+  assert.equal(isProperFraction(1, 0), false);
+  assert.equal(isProperFraction(5, 0), false);
+});
+test("Checking when numerator = 0", () => {
+  assert.equal(isProperFraction(0, 1), false);
+  assert.equal(isProperFraction(0, 5), false);
+});
+test("checking when numerator= 0 = denominator", () => {
+  assert.equal(isProperFraction(0, 0), false);
+});

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

@@ -3,14 +3,77 @@ import test from "node:test";
 
 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);
+  assert.equal(getCardValue("2♥"), 2);
+  assert.equal(getCardValue("5♣"), 5);
 });
-
-test("Arbitrary non-card string", () => {
-  assert.throws(() => getCardValue("invalid"), /Expected a number followed by a suit, but got "invalid"/, "Expected clear error");
+test("returns 11 for ace cards", () => {
+  assert.equal(getCardValue("A♠"), 11);
+  assert.equal(getCardValue("A♥"), 11);
+});
+test("returns 10 for cards with", () => {
+  assert.equal(getCardValue("J♠"), 10);
+  assert.equal(getCardValue("Q♥"), 10);
+  assert.equal(getCardValue("K♣"), 10);
+});
+test("returns 10 for cards with", () => {
+  assert.equal(getCardValue("10♣"), 10);
 });
 
-// TODO: What other invalid card cases can you think of?
+test("throws for invalid rank or suit", () => {
+  assert.throws(
+    () => getCardValue("invalid"),
+    /Expected a number followed by a suit, but got "invalid"/,
+    "Expected clear error"
+  );
+});
+test("throws for invalid rank", () => {
+  assert.throws(
+    () => getCardValue("11♠"),
+    /Expected a valid Rank instead got "11♠"/,
+    "Expected clear error"
+  );
+});
+test("throws for invalid suit when A is given as suit", () => {
+  assert.throws(
+    () => getCardValue("AA"),
+    /Expected a valid Suit instead got "AA"/,
+    "Expected clear error"
+  );
+});
+test("throws for invalid rank when 1 is given as Rank", () => {
+  assert.throws(
+    () => getCardValue("1♣"),
+    /Expected a valid Rank instead got "1♣"/,
+    "Expected clear error"
+  );
+});
+test("throws invalid suit when 0 is given as suit", () => {
+  assert.throws(
+    () => getCardValue("100"),
+    /Expected a valid Suit instead got "100"/,
+    "Expected clear error"
+  );
+});
+test("throws invalid input when empty space is given", () => {
+  assert.throws(
+    () => getCardValue(" "),
+    /Expected a valid Rank and Suit instead got " "/,
+    "Expected clear error"
+  );
+});
+test("throws invalid Rank when given empty space before the card", () => {
+  assert.throws(
+    () => getCardValue(" 10♠"),
+    /Expected a valid Rank instead got " 10♠"/,
+    "Expected clear error"
+  );
+});
+test("throws invalid input when given null as input", () => {
+  assert.throws(
+    () => getCardValue(null),
+    /Expected a valid Rank and Suit instead got null/,
+    "Expected clear error"
+  );
+});

implement-and-rewrite-tests/implement/1-get-angle-type.js

@@ -15,7 +15,16 @@
 // Acceptance criteria:
 // After you have implemented the function, write tests to cover all the cases, and
 // execute the code to ensure all tests pass.
-
 export function getAngleType(angle) {
-  // TODO: Implement this function
+  if (angle > 0 && angle < 90) return "Acute angle";
+  else if (angle == 90) {
+    return "Right angle";
+  } else if (angle > 90 && angle < 180) {
+    return "Obtuse angle";
+  } else if (angle == 180) {
+    return "Straight angle";
+  } else if (angle > 180 && angle < 360) {
+    return "Reflex angle";
+  }
+  return "Invalid angle";
 }

implement-and-rewrite-tests/implement/2-is-proper-fraction.js

@@ -12,7 +12,13 @@
 // Acceptance criteria:
 // After you have implemented the function, write tests to cover all the cases, and
 // execute the code to ensure all tests pass.
-
 export function isProperFraction(numerator, denominator) {
-  // TODO: Implement this function
+  if (numerator == 0) {
+    // 0 is not a proper fraction it is a whole number
+    return false;
+  }
+  if (Math.abs(numerator) < Math.abs(denominator)) {
+    return true;
+  }
+  return false;
 }

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

@@ -24,5 +24,55 @@
 // execute the code to ensure all tests pass.
 
 export function getCardValue(card) {
-  // TODO: Implement this function
+  if (card == null) {
+    throw new Error(`Expected a valid Rank and Suit instead got null`);
+  }
+  const suit = card.slice(-1);
+  const cardInput = card.length;
+  const validSuit = ["♠", "♥", "♣", "♦"];
+  const validRank = [
+    "A",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "10",
+    "J",
+    "Q",
+    "K",
+  ];
+  if (card == "invalid") {
+    throw new Error(`Expected a number followed by a suit, but got "${card}"`);
+  }
+
+  if (!validRank.includes(card.slice(0, -1)) && !validSuit.includes(suit)) {
+    throw new Error(`Expected a valid Rank and Suit instead got "${card}"`);
+  }
+  if (!validRank.includes(card.slice(0, -1))) {
+    throw new Error(`Expected a valid Rank instead got "${card}"`);
+  }
+  if (!validSuit.includes(suit)) {
+    throw new Error(`Expected a valid Suit instead got "${card}"`);
+  }
+
+  if (validSuit) {
+    if (cardInput == 2) {
+      if (card[0] == "A") {
+        return 11;
+      }
+      if (card[0] == "J" || card[0] == "Q" || card[0] == "K") {
+        return 10;
+      }
+      if (card[0] >= 2 && card[0] < 10) {
+        return Number(card[0]);
+      }
+    }
+    if (cardInput == 3 && card.slice(0, 2) === "10") {
+      return 10;
+    }
+  }
 }

implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js

@@ -4,13 +4,38 @@ import { getAngleType } from "../implement/1-get-angle-type.js";
 // including boundary and invalid cases.
 
 // Case 1: Acute angles
-test(`should return "Acute angle" when (0 < angle < 90)`, () => {
-  // Test various acute angles, including boundary cases
-  expect(getAngleType(1)).toEqual("Acute angle");
-  expect(getAngleType(45)).toEqual("Acute angle");
-  expect(getAngleType(89)).toEqual("Acute angle");
+describe(`valid angles`, () => {
+  test(`should return "Acute angle" when (0 < angle < 90)`, () => {
+    // Test various acute angles, including boundary cases
+    expect(getAngleType(1)).toEqual("Acute angle");
+    expect(getAngleType(45)).toEqual("Acute angle");
+    expect(getAngleType(89)).toEqual("Acute angle");
+  });
+  test(`should return"Right angle" when (angle = 90)`, () => {
+    expect(getAngleType(90)).toEqual("Right angle");
+  });
+  test(`should return "Obtuse angle"when (90<angle<180)`, () => {
+    expect(getAngleType(91)).toEqual("Obtuse angle");
+    expect(getAngleType(135)).toEqual("Obtuse angle");
+    expect(getAngleType(179)).toEqual("Obtuse angle");
+  });
+  test(`should return "Straight angle" when (angle = 180)`, () => {
+    expect(getAngleType(180)).toEqual("Straight angle");
+  });
+  test(`should return "Reflex angle" when (180 < angle <360)`, () => {
+    expect(getAngleType(181)).toEqual("Reflex angle");
+    expect(getAngleType(270)).toEqual("Reflex angle");
+    expect(getAngleType(359)).toEqual("Reflex angle");
+  });
 });
 
+describe(`Invalid angles`, () => {
+  test(`should return "Invalid angls"when given Invalid angle`, () => {
+    expect(getAngleType(0)).toEqual("Invalid angle");
+    expect(getAngleType(360)).toEqual("Invalid angle");
+    expect(getAngleType(-1)).toEqual("Invalid angle");
+  });
+});
 // Case 2: Right angle
 // Case 3: Obtuse angles
 // Case 4: Straight angle

implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js

@@ -6,3 +6,27 @@ import { isProperFraction } from "../implement/2-is-proper-fraction.js";
 test(`should return false when denominator is zero`, () => {
   expect(isProperFraction(1, 0)).toEqual(false);
 });
+test(`should return true when (denominator > numerator)`, () => {
+  expect(isProperFraction(1, 2)).toEqual(true);
+});
+test(`should return false when (denominator< numerator)`, () => {
+  expect(isProperFraction(2, 1)).toEqual(false);
+});
+test(`should return true when (denominator < numerator)`, () => {
+  expect(isProperFraction(1, -2)).toEqual(true);
+});
+test(`should return false when(numerator = 0)`, () => {
+  expect(isProperFraction(0, 1)).toEqual(false);
+});
+test(`should return false when(numerator = 0 and numerator = 0)`, () => {
+  expect(isProperFraction(0, 0)).toEqual(false);
+});
+test(`should return true when(numerator < denominator)`, () => {
+  expect(isProperFraction(-1, 2)).toEqual(true);
+});
+test(`should return true when the input is -ve |numerator|<|denominator|`, () => {
+  expect(isProperFraction(-1, -2)).toEqual(true);
+});
+test(`should return false when the input is -ve |numerator|>|denominator|`, () => {
+  expect(isProperFraction(-2, -1)).toEqual(false);
+});

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

@@ -1,11 +1,63 @@
 import { getCardValue } from "../implement/3-get-card-value.js";
 
-// TODO: Write tests in Jest syntax to cover all possible outcomes.
-
-// Case 1: Ace (A)
 test(`Should return 11 when given an ace card`, () => {
   expect(getCardValue("A♠")).toEqual(11);
 });
+test(`should retun the numeric value when given "numbered" cards`, () => {
+  expect(getCardValue("2♣")).toEqual(2);
+  expect(getCardValue("6♥")).toEqual(6);
+  expect(getCardValue("10♦")).toEqual(10);
+});
+test(`should retun 10 when given(J,Q,K)cards`, () => {
+  expect(getCardValue("J♣")).toEqual(10);
+  expect(getCardValue("Q♥")).toEqual(10);
+  expect(getCardValue("K♦")).toEqual(10);
+});
+test(`throws for invalid cards`, () => {
+  expect(() => {
+    getCardValue("invalid");
+  }).toThrow(`Expected a number followed by a suit, but got "invalid"`);
+});
+test(`throws for invalid rank`, () => {
+  expect(() => {
+    getCardValue("1♥");
+  }).toThrow(`Expected a valid Rank instead got "1♥"`);
+});
+test(`throws for invalid suit`, () => {
+  expect(() => {
+    getCardValue("AS");
+  }).toThrow(`Expected a valid Suit instead got "AS"`);
+});
+test(`throws for invalid input`, () => {
+  expect(() => {
+    getCardValue("100");
+  }).toThrow(`Expected a valid Suit instead got "100"`);
+});
+test(`throws for invalid rank`, () => {
+  expect(() => {
+    getCardValue("15♥");
+  }).toThrow(`Expected a valid Rank instead got "15♥"`);
+});
+test(`throws for invalid input`, () => {
+  expect(() => {
+    getCardValue(" ");
+  }).toThrow(`Expected a valid Rank and Suit instead got " "`);
+});
+test(`throws for invalid input with space ending`, () => {
+  expect(() => {
+    getCardValue("4♣ ");
+  }).toThrow(`Expected a valid Rank and Suit instead got "4♣ "`);
+});
+test(`throws for invalid input`, () => {
+  expect(() => {
+    getCardValue("♣4");
+  }).toThrow(`Expected a valid Rank and Suit instead got "♣4"`);
+});
+test(`throws for invalid input`, () => {
+  expect(() => {
+    getCardValue(null);
+  }).toThrow(`Expected a valid Rank and Suit instead got null`);
+});
 
 // Suggestion: Group the remaining test data into these categories:
 //   Number Cards (2-10)
@@ -15,4 +67,3 @@ 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
-