Completion of 1-implement-and-rewrite-tests

Author: Ayogit1

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

@@ -16,6 +16,19 @@
 
 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";
+  } else {
+    return "Invalid angle";
+  }
 }
 
 // The line below allows us to load the getAngleType function into tests in other files.
@@ -35,3 +48,19 @@ function assertEquals(actualOutput, targetOutput) {
 // Example: Identify Right Angles
 const right = getAngleType(90);
 assertEquals(right, "Right angle");
+
+const acute = getAngleType(70);
+assertEquals(acute, "Acute angle");
+
+const obtuse = getAngleType(140);
+assertEquals(obtuse, "Obtuse angle");
+
+const straight = getAngleType(180);
+assertEquals(straight, "Straight angle");
+
+const reflex = getAngleType(190);
+assertEquals(reflex, "Reflex angle");
+
+const invalid = getAngleType(370);
+assertEquals(invalid, "Invalid angle");
+

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

@@ -12,6 +12,11 @@
 
 function isProperFraction(numerator, denominator) {
   // TODO: Implement this function
+  if (numerator < denominator) {
+    return "true";
+  } else {
+    return "false";
+  }
 }
 
 // The line below allows us to load the isProperFraction function into tests in other files.
@@ -30,4 +35,6 @@ function assertEquals(actualOutput, targetOutput) {
 // What combinations of numerators and denominators should you test?
 
 // Example: 1/2 is a proper fraction
-assertEquals(isProperFraction(1, 2), true);
+assertEquals(isProperFraction(1, 2), "true");
+assertEquals(isProperFraction(2, 2), "false");
+assertEquals(isProperFraction(7, 4), "false");

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

@@ -23,6 +23,16 @@
 
 function getCardValue(card) {
   // TODO: Implement this function
+  rankCard = card.slice(0, 1);
+  if (rankCard === "A") {
+    return 11;
+  } else if (rankCard === "J" || rankCard === "Q" || rankCard === "K") {
+    return 10;
+  } else if (+rankCard >= 2 && +rankCard <= 10) {
+    return +rankCard;
+  } else {
+    return rankCard.toThrow();
+  }
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
@@ -47,6 +57,8 @@ try {
 
   // This line will not be reached if an error is thrown as expected
   console.error("Error was not thrown for invalid card");
-} catch (e) {}
+} catch (e) { }
 
 // What other invalid card cases can you think of?
+
+getCardValue("13♠");

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

@@ -14,7 +14,31 @@ test(`should return "Acute angle" when (0 < angle < 90)`, () => {
 });
 
 // Case 2: Right angle
+test(`should return "Right angle" when (angle === 90)`, () => {
+  expect(getAngleType(90)).toEqual("Right angle");
+});
+
 // Case 3: Obtuse angles
+test(`should return "Obtuse angle" when (90 < angle < 180)`, () => {
+  expect(getAngleType(91)).toEqual("Obtuse angle");
+  expect(getAngleType(145)).toEqual("Obtuse angle");
+  expect(getAngleType(189)).toEqual("Obtuse angle");
+});
 // Case 4: Straight angle
+test(`should return "Straight angle" when (angle === 180)`, () => {
+  expect(getAngleType(180)).toEqual("Straight angle");
+
+});
 // Case 5: Reflex angles
+test(`should return "Reflex angle" when (180 < angle <= 360)`, () => {
+  expect(getAngleType(181)).toEqual("Reflex angle");
+  expect(getAngleType(245)).toEqual("Reflex angle");
+  expect(getAngleType(360)).toEqual("Reflex angle");
+});
+
 // Case 6: Invalid angles
+test(`should return "Invalid angle" when (angle > 360)`, () => {
+  expect(getAngleType(361)).toEqual("Invalid angle");
+  expect(getAngleType(445)).toEqual("Invalid angle");
+  expect(getAngleType(589)).toEqual("Invalid angle");
+});

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

@@ -8,3 +8,21 @@ const isProperFraction = require("../implement/2-is-proper-fraction");
 test(`should return false when denominator is zero`, () => {
   expect(isProperFraction(1, 0)).toEqual(false);
 });
+
+// positives:
+test(`should return true when a numerator is less than denominator`, () => {
+  expect(isProperFraction(1, 2)).toEqual(true);
+});
+
+test(`should return false when a numerator is greater than denominator`, () => {
+  expect(isProperFraction(5, 4)).toEqual(false);
+});
+
+// negatives:
+test(`should return true when a numerator is less than denominator`, () => {
+  expect(isProperFraction(-1, 2)).toEqual(tue);
+});
+
+test(`should return false when a numerator is greater than denominator`, () => {
+  expect(isProperFraction(5, -4)).toEqual(false);
+});

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

@@ -11,8 +11,34 @@ test(`Should return 11 when given an ace card`, () => {
 
 // Suggestion: Group the remaining test data into these categories:
 //   Number Cards (2-10)
-//   Face Cards (J, Q, K)
-//   Invalid Cards
+test(`Should return the numeric value when the card is a number card ("2" to "10")`, () => {
+  const numberCards = [
+    { card: "2", value: 2 },
+    { card: "3", value: 3 },
+    { card: "4", value: 4 },
+    { card: "5", value: 5 },
+    { card: "6", value: 6 },
+    { card: "7", value: 7 },
+    { card: "8", value: 8 },
+    { card: "9", value: 9 },
+    { card: "10", value: 10 }
+  ];
+
+  numberCards.forEach(({ card, value }) => {
+    expect(getCardValue(card)).toEqual(value);
+  });
+  //   Face Cards (J, Q, K)
+  test(`Should return 10 when given face card ("J", "Q", "K")`, () => {
+    expect(getCardValue("J♣")).toEqual(10);
+  });
+
+  test(`Should return 10 when given face card ("J", "Q", "K")`, () => {
+    expect(getCardValue("Q♦")).toEqual(10);
+  });
+
+  test(`Should return 10 when given face card ("J", "Q", "K")`, () => {
+    expect(getCardValue("K♦")).toEqual(10);
+  });
 
 // To learn how to test whether a function throws an error as expected in Jest,
 // please refer to the Jest documentation: