Sprint 3 implement and rewrite tests

arunkumarakilan · arunkumarakilan · commit c6fe4be976c7 · 2026-03-12T19:30:49.000Z
diff --git a/.prettierignore b/.prettierignore
@@ -0,0 +1,3 @@
+# Ignore artifacts:
+build
+coverage
diff --git a/.prettierrc b/.prettierrc
@@ -1,19 +1 @@
-{
-  "arrowParens": "always",
-  "bracketSpacing": true,
-  "embeddedLanguageFormatting": "auto",
-  "htmlWhitespaceSensitivity": "css",
-  "insertPragma": false,
-  "jsxBracketSameLine": false,
-  "jsxSingleQuote": false,
-  "printWidth": 80,
-  "proseWrap": "preserve",
-  "quoteProps": "as-needed",
-  "requirePragma": false,
-  "semi": true,
-  "singleQuote": false,
-  "tabWidth": 2,
-  "trailingComma": "es5",
-  "useTabs": false,
-  "vueIndentScriptAndStyle": false
-}
+{}
diff --git a/Sprint-1/1-key-exercises/2-initials.js b/Sprint-1/1-key-exercises/2-initials.js
@@ -8,4 +8,3 @@ let lastName = "Johnson";
 let initials = ``;
 
 // https://www.google.com/search?q=get+first+character+of+string+mdn
-
diff --git a/Sprint-1/3-mandatory-interpret/3-to-pounds.js b/Sprint-1/3-mandatory-interpret/3-to-pounds.js
@@ -2,13 +2,13 @@ const penceString = "399p";
 
 const penceStringWithoutTrailingP = penceString.substring(
   0,
-  penceString.length - 1
+  penceString.length - 1,
 );
 
 const paddedPenceNumberString = penceStringWithoutTrailingP.padStart(3, "0");
 const pounds = paddedPenceNumberString.substring(
   0,
-  paddedPenceNumberString.length - 2
+  paddedPenceNumberString.length - 2,
 );
 
 const pence = paddedPenceNumberString
diff --git a/Sprint-1/readme.md b/Sprint-1/readme.md
@@ -12,7 +12,7 @@ This README will guide you through the different sections for this week.
 
 ## 1 Exercises
 
-In this section, you'll have a short program and task. Some of the syntax may be unfamiliar - in this case, you'll need to look things up in documentation. 
+In this section, you'll have a short program and task. Some of the syntax may be unfamiliar - in this case, you'll need to look things up in documentation.
 
 https://developer.mozilla.org/en-US/docs/Web/JavaScript
 
@@ -28,7 +28,7 @@ You must use documentation to make sense of anything unfamiliar - learning how t
 
 You can also use `console.log` to check the value of different variables in the code.
 
-https://developer.mozilla.org/en-US/docs/Web/JavaScript 
+https://developer.mozilla.org/en-US/docs/Web/JavaScript
 
 ## 4 Explore - Stretch 💪
 
diff --git a/Sprint-2/3-mandatory-implement/1-bmi.js b/Sprint-2/3-mandatory-implement/1-bmi.js
@@ -15,5 +15,5 @@
 // It should return their Body Mass Index to 1 decimal place
 
 function calculateBMI(weight, height) {
-    // return the BMI of someone based off their weight and height
-}
+  // return the BMI of someone based off their weight and height
+}
diff --git a/Sprint-2/5-stretch-extend/format-time.js b/Sprint-2/5-stretch-extend/format-time.js
@@ -14,12 +14,12 @@ const currentOutput = formatAs12HourClock("08:00");
 const targetOutput = "08:00 am";
 console.assert(
   currentOutput === targetOutput,
-  `current output: ${currentOutput}, target output: ${targetOutput}`
+  `current output: ${currentOutput}, target output: ${targetOutput}`,
 );
 
 const currentOutput2 = formatAs12HourClock("23:00");
 const targetOutput2 = "11:00 pm";
 console.assert(
   currentOutput2 === targetOutput2,
-  `current output: ${currentOutput2}, target output: ${targetOutput2}`
+  `current output: ${currentOutput2}, target output: ${targetOutput2}`,
 );
diff --git a/Sprint-3/1-implement-and-rewrite-tests/README.md b/Sprint-3/1-implement-and-rewrite-tests/README.md
@@ -5,14 +5,13 @@ to choose test values that thoroughly test a function.
 
 ## 1 Implement solutions
 
-In the `implement` directory you've got a number of functions you'll need to implement.
-For each function, you also have a number of different cases you'll need to check for your function.
+Here is a recommended order:
 
-Write your assertions and build up your program case by case. Don't rush to a solution. The point of these assignments is to learn how to write assertions and build up a program step by step.
+1. `1-get-angle-type.js`In the `implement` directory you've got a number of functions you'll need to implement.
+   For each function, you also have a number of different cases you'll need to check for your function.
 
-Here is a recommended order:
+Write your assertions and build up your program case by case. Don't rush to a solution. The point of these assignments is to learn how to write assertions and build up a program step by step.
 
-1. `1-get-angle-type.js`
 2. `2-is-proper-fraction.js`
 3. `3-get-card-value.js`
 
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -15,7 +15,19 @@
 // execute the code to ensure all tests pass.
 
 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.
@@ -27,11 +39,29 @@ module.exports = getAngleType;
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
-    `Expected ${actualOutput} to equal ${targetOutput}`
+    `Expected ${actualOutput} to equal ${targetOutput}`,
   );
 }
 
 // TODO: Write tests to cover all cases, including boundary and invalid cases.
 // Example: Identify Right Angles
-const right = getAngleType(90);
+let invalid = getAngleType(0);
+assertEquals(invalid, "Invalid angle");
+let acute = getAngleType(1);
+assertEquals(acute, "Acute angle");
+acute = getAngleType(89);
+assertEquals(acute, "Acute angle");
+let right = getAngleType(90);
 assertEquals(right, "Right angle");
+let obtuse = getAngleType(91);
+assertEquals(obtuse, "Obtuse angle");
+obtuse = getAngleType(179);
+assertEquals(obtuse, "Obtuse angle");
+const straight = getAngleType(180);
+assertEquals(straight, "Straight angle");
+let reflex = getAngleType(181);
+assertEquals(reflex, "Reflex angle");
+reflex = getAngleType(359);
+assertEquals(reflex, "Reflex angle");
+invalid = getAngleType(400);
+assertEquals(invalid, "Invalid angle");
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
@@ -11,7 +11,11 @@
 // execute the code to ensure all tests pass.
 
 function isProperFraction(numerator, denominator) {
-  // TODO: Implement this function
+  if (denominator === 0) {
+    return false;
+  } 
+      return Math.abs(numerator) < Math.abs(denominator);
+  
 }
 
 // The line below allows us to load the isProperFraction function into tests in other files.
@@ -22,7 +26,7 @@ module.exports = isProperFraction;
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
-    `Expected ${actualOutput} to equal ${targetOutput}`
+    `Expected ${actualOutput} to equal ${targetOutput}`,
   );
 }
 
@@ -31,3 +35,10 @@ function assertEquals(actualOutput, targetOutput) {
 
 // Example: 1/2 is a proper fraction
 assertEquals(isProperFraction(1, 2), true);
+assertEquals(isProperFraction(5, 4), false);
+assertEquals(isProperFraction(3, 3), false);
+assertEquals(isProperFraction(0, 5), true);
+assertEquals(isProperFraction(1, 0), false);
+assertEquals(isProperFraction(-1, 2), true);
+assertEquals(isProperFraction(1, -2), true);
+assertEquals(isProperFraction(-1, -2), true);
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -22,31 +22,86 @@
 // execute the code to ensure all tests pass.
 
 function getCardValue(card) {
-  // TODO: Implement this function
+  if (typeof card !== "string" || card.length < 2) {
+    throw new Error("Invalid card");
+  }
+  const suit = card.slice(-1);
+  const rank = card.slice(0, -1);
+
+  const validSuits = ["♠", "♥", "♦", "♣"];
+  const validRanks = [
+    "A",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "10",
+    "J",
+    "Q",
+    "K",
+  ];
+
+  if (!validSuits.includes(suit) || !validRanks.includes(rank)) {
+    throw new Error("Invalid card");
+  } else if (rank == "A") {
+    return 11;
+  } else if (["J", "Q", "K"].includes(rank)) {
+    return 10;
+  } else {
+    return Number(rank);
+  }
 }
 
 // The line below allows us to load the getCardValue function into tests in other files.
 // This will be useful in the "rewrite tests with jest" step.
+//module.exports = getCardValue;
 module.exports = getCardValue;
-
 // Helper functions to make our assertions easier to read.
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
-    `Expected ${actualOutput} to equal ${targetOutput}`
+    `Expected ${actualOutput} to equal ${targetOutput}`,
   );
 }
 
 // TODO: Write tests to cover all outcomes, including throwing errors for invalid cards.
 // Examples:
 assertEquals(getCardValue("9♠"), 9);
+assertEquals(getCardValue("A♠"), 11);
+assertEquals(getCardValue("K♦"), 10);
+assertEquals(getCardValue("10♥"), 10);
 
 // Handling invalid cards
 try {
-  getCardValue("invalid");
+  getCardValue("11♠");
+  console.error("Error was not thrown for invalid card");
+} catch (e) {}
+try {
+  getCardValue("A?");
+  console.error("Error was not thrown for invalid card");
+} catch (e) {}
+try {
+  getCardValue("A");
+
+  console.error("Error was not thrown for invalid card");
+} catch (e) {}
+try {
+  getCardValue(10);
 
-  // This line will not be reached if an error is thrown as expected
   console.error("Error was not thrown for invalid card");
 } catch (e) {}
 
 // What other invalid card cases can you think of?
+//try {
+//getCardValue("AA");
+//console.error("Error was not thrown for invalid card");
+//} catch (e) {}
+//try {
+//getCardValue("1♠");
+
+//console.error("Error was not thrown for invalid card");
+//} catch (e) {}
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -9,9 +9,27 @@ const getAngleType = require("../implement/1-get-angle-type");
 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(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(359)).toEqual("Reflex angle");
+});
+test(`should return "invalid angle when angles outside the valid range`, () => {
+  expect(getAngleType(0)).toEqual("Invalid angle");
+   expect(getAngleType(360)).toEqual("Invalid angle");
+   expect(getAngleType(-10)).toEqual("Invalid angle");
+});
 
 // Case 2: Right angle
 // Case 3: Obtuse angles
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -4,7 +4,24 @@ const isProperFraction = require("../implement/2-is-proper-fraction");
 
 // TODO: Write tests in Jest syntax to cover all combinations of positives, negatives, zeros, and other categories.
 
-// Special case: numerator is zero
+
 test(`should return false when denominator is zero`, () => {
   expect(isProperFraction(1, 0)).toEqual(false);
 });
+test(`Should return true when numerator is zero`, () => {
+  expect(isProperFraction(0, 5)).toEqual(true);
+});
+test(`should return true when denominator is greater than numerator`, () => {
+  expect(isProperFraction(1, 2)).toEqual(true);
+});
+test(`should return false when numerator is greater than denominator`, () => {
+  expect(isProperFraction(5, 4)).toEqual(false);
+});
+test(`should return false when numerator is equals to denominator`, () => {
+  expect(isProperFraction(3, 3)).toEqual(false);
+});
+test("should return true when abs(numerator) < abs(denominator)", () => {
+  expect(isProperFraction(-1, 2)).toEqual(true);
+  expect(isProperFraction(1, -2)).toEqual(true);
+  expect(isProperFraction(-1, -2)).toEqual(true);
+});
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -8,13 +8,37 @@ const getCardValue = require("../implement/3-get-card-value");
 test(`Should return 11 when given an ace card`, () => {
   expect(getCardValue("A♠")).toEqual(11);
 });
-
-// Suggestion: Group the remaining test data into these categories:
 //   Number Cards (2-10)
+test("should return the value of number cards (2–10)", () => {
+  expect(getCardValue("2♣")).toEqual(2);
+  expect(getCardValue("5♦")).toEqual(5);
+  expect(getCardValue("9♥")).toEqual(9);
+  expect(getCardValue("10♠")).toEqual(10);
+});
 //   Face Cards (J, Q, K)
+test("should return 10 for face cards", () => {
+  expect(getCardValue("J♣")).toEqual(10);
+  expect(getCardValue("Q♦")).toEqual(10);
+  expect(getCardValue("K♥")).toEqual(10);
+});
 //   Invalid Cards
+test("should throw error for invalid ranks", () => {
+  expect(() => getCardValue("11♠")).toThrow();
+});
+
+test("should throw error for invalid suits", () => {
+  expect(() => getCardValue("A?")).toThrow();
+});
+
+test("should throw error for missing suits", () => {
+  expect(() => getCardValue("A")).toThrow();
+});
+
+test("should throw error for non-string input", () => {
+  expect(() => getCardValue(10)).toThrow();
+});
 
 // 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
-
+  
diff --git a/Sprint-3/1-implement-and-rewrite-tests/testing-guide.md b/Sprint-3/1-implement-and-rewrite-tests/testing-guide.md
diff --git a/Sprint-3/2-practice-tdd/count.js b/Sprint-3/2-practice-tdd/count.js
diff --git a/Sprint-3/4-stretch/password-validator.js b/Sprint-3/4-stretch/password-validator.js
diff --git a/Sprint-3/4-stretch/password-validator.test.js b/Sprint-3/4-stretch/password-validator.test.js
diff --git a/package.json b/package.json
diff --git a/readme.md b/readme.md

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+# Ignore artifacts:`
	`2`	`+build`
	`3`	`+coverage`
Original file line number	Diff line number	Diff line change
`@@ -8,4 +8,3 @@ let lastName = "Johnson";`
`8`	`8`	let initials = ``;
`9`	`9`
`10`	`10`	`// https://www.google.com/search?q=get+first+character+of+string+mdn`
`11`		`-`