Manchester | 26-ITP-| John Robinson | Sprint 3 | Implement and rewrite tests

Sprint-1/1-key-exercises/1-count.js

@@ -4,3 +4,8 @@ count = count + 1;
 
 // Line 1 is a variable declaration, creating the count variable with an initial value of 0
 // Describe what line 3 is doing, in particular focus on what = is doing
+
+// Answer: Line 3 is updating the value of the variable 'count' by adding 1 to its current value.
+// The = operator is used to update / assign a new value to the variable 'count'.
+// It takes the current value of 'count', adds 1 to it, and then assigns that new value back to 'count'.
+// 

Sprint-1/1-key-exercises/2-initials.js

@@ -5,7 +5,8 @@ let lastName = "Johnson";
 // Declare a variable called initials that stores the first character of each string.
 // This should produce the string "CKJ", but you must not write the characters C, K, or J in the code of your solution.
 
-let initials = ``;
+let initials = `${firstName[0]}${middleName[0]}${lastName[0]}`;
+// console.log(initials);
 
 // https://www.google.com/search?q=get+first+character+of+string+mdn
 

Sprint-1/1-key-exercises/3-paths.js

@@ -17,7 +17,7 @@ console.log(`The base part of ${filePath} is ${base}`);
 // Create a variable to store the dir part of the filePath variable
 // Create a variable to store the ext part of the variable
 
-const dir = ;
-const ext = ;
+const dir = filePath.slice(0, lastSlashIndex);
+const ext = base.slice(base.lastIndexOf(".") + 1);
 
 // https://www.google.com/search?q=slice+mdn

Sprint-1/1-key-exercises/4-random.js

@@ -7,3 +7,9 @@ const num = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
 // Try breaking down the expression and using documentation to explain what it means
 // It will help to think about the order in which expressions are evaluated
 // Try logging the value of num and running the program several times to build an idea of what the program is doing
+
+// Answer: The variable we have created 'num' generates a random number, this is done by using the Math.random() function
+// The Math.Random is a built-in function that creates a random number between 0 and 1, but not including 1. The next part
+// of the expression multiplies the random number by (100 - 1 + 1) which is 100, this means that the random number will be between 0 and 100.
+// Then +1 minimum is added to the random number, this means that the random number will be between 1 and 100. Finally, the Math.floor() 
+// function is used to round the random number down to the nearest whole number.

Sprint-1/2-mandatory-errors/0.js

@@ -1,2 +1,2 @@
-This is just an instruction for the first activity - but it is just for human consumption
-We don't want the computer to run these 2 lines - how can we solve this problem?
+//This is just an instruction for the first activity - but it is just for human consumption
+//We don't want the computer to run these 2 lines - how can we solve this problem?

Sprint-1/2-mandatory-errors/1.js

@@ -1,4 +1,4 @@
 // trying to create an age variable and then reassign the value by 1
 
-const age = 33;
+let age = 33;
 age = age + 1;

Sprint-1/2-mandatory-errors/2.js

@@ -1,5 +1,4 @@
 // Currently trying to print the string "I was born in Bolton" but it isn't working...
 // what's the error ?
-
-console.log(`I was born in ${cityOfBirth}`);
 const cityOfBirth = "Bolton";
+console.log(`I was born in ${cityOfBirth}`);

Sprint-1/2-mandatory-errors/3.js

@@ -1,5 +1,11 @@
 const cardNumber = 4533787178994213;
-const last4Digits = cardNumber.slice(-4);
+const last4Digits = cardNumber.toString().slice(-4);
+
+console.log(last4Digits);
+
+//The const Last4Digits should store the last 4 characters of the cardNumber and return it
+
+//The Built in method slice() doesnt work on numbers, only on strings.
 
 // The last4Digits variable should store the last 4 digits of cardNumber
 // However, the code isn't working

Sprint-1/2-mandatory-errors/4.js

@@ -1,2 +1,2 @@
-const 12HourClockTime = "8:53pm";
-const 24hourClockTime = "20:53";
+const TwelveHourClockTime = "8:53 pm";
+const TwentyFourHourClockTime = "20:53";

Sprint-1/3-mandatory-interpret/1-percentage-change.js

@@ -2,7 +2,7 @@ let carPrice = "10,000";
 let priceAfterOneYear = "8,543";
 
 carPrice = Number(carPrice.replaceAll(",", ""));
-priceAfterOneYear = Number(priceAfterOneYear.replaceAll("," ""));
+priceAfterOneYear = Number(priceAfterOneYear.replaceAll(",", ""));
 
 const priceDifference = carPrice - priceAfterOneYear;
 const percentageChange = (priceDifference / carPrice) * 100;
@@ -12,11 +12,16 @@ console.log(`The percentage change is ${percentageChange}`);
 // Read the code and then answer the questions below
 
 // a) How many function calls are there in this file? Write down all the lines where a function call is made
+// A) 5 in total - lines 4, 5, 10
 
 // b) Run the code and identify the line where the error is coming from - why is this error occurring? How can you fix this problem?
+// A) Missing comma in line 5 in function .replaceAll which is causing the error.
 
 // c) Identify all the lines that are variable reassignment statements
+// A) lines 4 and 5 are variable reassignment statements.
 
 // d) Identify all the lines that are variable declarations
+// A) Lines 1, 2, 7 and 8
 
 // e) Describe what the expression Number(carPrice.replaceAll(",","")) is doing - what is the purpose of this expression?
+// A) The expression is converting the string value of carPrice into a number and removing the commas so that it can be used in a mathematical calculation.

Sprint-1/3-mandatory-interpret/2-time-format.js

@@ -12,14 +12,20 @@ console.log(result);
 // For the piece of code above, read the code and then answer the following questions
 
 // a) How many variable declarations are there in this program?
+// A) 6
 
 // b) How many function calls are there?
+// A) 1 (console.log function)
 
 // c) Using documentation, explain what the expression movieLength % 60 represents
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators
+// A) This expression is using the modulo operator that finds the remainder of the movieLength after being divided by 60.
 
 // d) Interpret line 4, what does the expression assigned to totalMinutes mean?
+// A) The expression is calculating the total number of minutes in the movie (not including the remaining seconds).
 
 // e) What do you think the variable result represents? Can you think of a better name for this variable?
+// A) The variable gives the total length of the movie in hours, minutes, and seconds. A better name for this variable could be "formattedMovieLength".
 
 // f) Try experimenting with different values of movieLength. Will this code work for all values of movieLength? Explain your answer
+// A) The code would have an error if the user was to inputs a value with commas, letters or as a string.

Sprint-1/3-mandatory-interpret/3-to-pounds.js

@@ -25,3 +25,11 @@ console.log(`£${pounds}.${pence}`);
 
 // To begin, we can start with
 // 1. const penceString = "399p": initialises a string variable with the value "399p"
+// 2. Line 3: uses the substring method to remove the "p" from the end of the string
+// 3. Line 8: the variable paddedPenceNumberString is used to ensure that the string has at least 3 characters,
+// if not it will add a zero to the start of the string
+// 4. Line 9 - 11: the variable pounds uses the substring method in the same way as line 3 but this time removes the last two characters
+// the result is now stored in the const 'pounds' to be used in the final output
+// 5. Line 14 - 16: the variable pence also uses the substring method to extract the last two characters from paddedPenceNumberString
+// the result is now stored in the const 'pence' to be used in the final output, a '0' is added to the end of the string if there is only one character
+// 6. Line 18: the console.log function prints our output - the values stored in the consts 'pounds' and 'pence'.

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.
@@ -35,3 +47,10 @@ function assertEquals(actualOutput, targetOutput) {
 // Example: Identify Right Angles
 const right = getAngleType(90);
 assertEquals(right, "Right angle");
+assertEquals(getAngleType(0), "Invalid angle");
+assertEquals(getAngleType(-1), "Invalid angle");
+assertEquals(getAngleType(360), "Invalid angle");
+assertEquals(getAngleType(45), "Acute angle");
+assertEquals(getAngleType(100), "Obtuse angle");
+assertEquals(getAngleType(180), "Straight angle");
+assertEquals(getAngleType(200), "Reflex angle");

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

@@ -11,10 +11,13 @@
 // 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.
+
+//The line below allows us to load the isProperFraction function into tests in other files.
 // This will be useful in the "rewrite tests with jest" step.
 module.exports = isProperFraction;
 
@@ -31,3 +34,10 @@ function assertEquals(actualOutput, targetOutput) {
 
 // Example: 1/2 is a proper fraction
 assertEquals(isProperFraction(1, 2), true);
+assertEquals(isProperFraction(2, 1), false);
+assertEquals(isProperFraction(2, 4), true);
+assertEquals(isProperFraction(10, 5), false);
+assertEquals(isProperFraction(-1, -2), true);
+assertEquals(isProperFraction(3, 0), false);
+assertEquals(isProperFraction(0, 5), true);
+assertEquals(isProperFraction(3, 3), false);

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

@@ -22,9 +22,49 @@
 // 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("Error: Invalid card format");
+ }
+
+ const rank = card.slice(0, -1);
+ const suit = card.slice(-1);
+
+ const validSuits = ["♠", "♥", "♦", "♣"];
+ if (!validSuits.includes(suit)) {
+ throw new Error("Error: Invalid suit");
+ }
+
+ switch (rank) {
+ case "A":
+ return 11;
+ case "J":
+ case "Q":
+ case "K":
+ return 10;
+ case "2":
+ return 2;
+ case "3":
+ return 3;
+ case "4":
+ return 4;
+ case "5":
+ return 5;
+ case "6":
+ return 6;
+ case "7":
+ return 7;
+ case "8":
+ return 8;
+ case "9":
+ return 9;
+ case "10":
+ return 10;
+
+ default:
+ throw new Error("Error: Invalid card format");
 }
 
+}
 // 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;
@@ -40,8 +80,13 @@ function assertEquals(actualOutput, 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("J♣"), 10);
+assertEquals(getCardValue("Q♦"), 10);
+assertEquals(getCardValue("K♥"), 10);
+assertEquals(getCardValue("2♥"), 2);
+assertEquals(getCardValue("A♠"), 11);
 
-// Handling invalid cards
 try {
  getCardValue("invalid");
 
@@ -52,3 +97,4 @@ try {
 }
 
 // What other invalid card cases can you think of?
+// A) 1♠, 11♠, AA♠, ♠♠, 10 

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

@@ -14,7 +14,34 @@ 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(120)).toEqual("Obtuse angle");
+ expect(getAngleType(179)).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(265)).toEqual("Reflex angle");
+ expect(getAngleType(359)).toEqual("Reflex angle");
+});
+
 // Case 6: Invalid angles
+test(`should return "Invalid angle" when angle is not a number or is outside the valid range`, () => {
+ expect(getAngleType("not a number")).toEqual("Invalid angle");
+ expect(getAngleType(-1)).toEqual("Invalid angle");
+ expect(getAngleType(361)).toEqual("Invalid angle");
+ expect(getAngleType(0)).toEqual("Invalid angle");
+ expect(getAngleType(360)).toEqual("Invalid angle");
+});

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

@@ -8,3 +8,29 @@ const isProperFraction = require("../implement/2-is-proper-fraction");
 test(`should return false when denominator is zero`, () => {
  expect(isProperFraction(1, 0)).toEqual(false);
 });
+
+
+// (True) - Proper fractions
+test(`should return true when |numerator| < |denominator|`, () => {
+ expect(isProperFraction(1, 2)).toEqual(true);
+ expect(isProperFraction(-1, 2)).toEqual(true);
+ expect(isProperFraction(1, -3)).toEqual(true);
+ expect(isProperFraction(-1, -3)).toEqual(true);
+ expect(isProperFraction(2, 4)).toEqual(true);
+});
+
+// (False) - Improper fractions
+test(`should return false when |numerator| >= |denominator|`, () => {
+ expect(isProperFraction(2, 1)).toEqual(false);
+ expect(isProperFraction(-2, 1)).toEqual(false);
+ expect(isProperFraction(2, -1)).toEqual(false);
+ expect(isProperFraction(-2, -1)).toEqual(false);
+ expect(isProperFraction(3, 3)).toEqual(false);
+});
+
+// (True) - Zero numerator
+test(`should return true when numerator is zero and denominator is non-zero`, () => {
+ expect(isProperFraction(0, 1)).toEqual(true);
+ expect(isProperFraction(0, 5)).toEqual(true);
+ expect(isProperFraction(0, -5)).toEqual(true);
+});

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

@@ -11,8 +11,32 @@ test(`Should return 11 when given an ace card`, () => {
 
 // Suggestion: Group the remaining test data into these categories:
 // Number Cards (2-10)
+test(`Should return the numeric value when given a number card`, () => {
+ expect(getCardValue("2♠")).toEqual(2);
+ expect(getCardValue("10♥")).toEqual(10);
+ expect(getCardValue("7♦")).toEqual(7);
+ expect(getCardValue("5♣")).toEqual(5);
+});
+
 // Face Cards (J, Q, K)
+test(`Should return 10 when given a face card`, () => {
+ expect(getCardValue("J♣")).toEqual(10);
+ expect(getCardValue("Q♦")).toEqual(10);
+ expect(getCardValue("K♠")).toEqual(10);
+ expect(getCardValue("K♥")).toEqual(10);
+});
+
 // Invalid Cards
+test(`Should throw an error when given an invalid card`, () => {
+ expect(() => getCardValue("1♠")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("11♠")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("AA♠")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("♠♠")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("10")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("A♠♠")).toThrow("Error: Invalid card format");
+ expect(() => getCardValue("0♠")).toThrow("Error: Invalid card format");
+
+});
 
 // To learn how to test whether a function throws an error as expected in Jest,
 // please refer to the Jest documentation:

package.json

@@ -11,5 +11,14 @@
  "license": "ISC",
  "dependencies": {
  "jest": "^29.7.0"
- }
-}
+ },
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/JohnRob-jnr/Module-Structuring-and-Testing-Data.git"
+ },
+ "type": "commonjs",
+ "bugs": {
+ "url": "https://github.com/JohnRob-jnr/Module-Structuring-and-Testing-Data/issues"
+ },
+ "homepage": "https://github.com/JohnRob-jnr/Module-Structuring-and-Testing-Data#readme"
+}