London | 25-ITP-September | Ammad Ur Rehman | Sprint 3 | 03 Complete Sprint 3 practice TDD coursework

Sprint-3/2-practice-tdd/count.js

@@ -1,5 +1,25 @@
 function countChar(stringOfCharacters, findCharacter) {
-  return 5
+  if (typeof stringOfCharacters !== "string") {
+    throw new TypeError(
+      "The argument for parameter stringOfCharacters is not a String type"
+    );
+  }
+
+  if (typeof findCharacter !== "string") {
+    throw new TypeError(
+      "The argument for parameter findCharacter is not a String type"
+    );
+  }
+
+  if (findCharacter.length !== 1) {
+    throw new Error(
+      "Parameter findCharacter is must contain a single character"
+    );
+  }
+
+  return stringOfCharacters.split("").reduce((accumulator, character) => {
+    return accumulator + (character === findCharacter ? 1 : 0);
+  }, 0);
 }
 
 module.exports = countChar;

Sprint-3/2-practice-tdd/count.test.js

@@ -22,3 +22,49 @@ test("should count multiple occurrences of a character", () => {
 // And a character char that does not exist within the case-sensitive str,
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of the char were found in the case-sensitive str.
+
+test("should count no occurrences of z characters", () => {
+  const str = "aaaaa";
+  const char = "z";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("should return 0 for an empty string and a non-empty character", () => {
+  const str = "";
+  const char = "z";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("should return 0 for an empty string and a whitespace character", () => {
+  const str = "";
+  const char = " ";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("should return 0 when the string contains the character in a different case", () => {
+  const str = "aBcDeF";
+  const char = "A";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+test("throws error when the first argument is not a string", () => {
+  expect(() => countChar(1234, "1")).toThrow(
+    "The argument for parameter stringOfCharacters is not a String type"
+  );
+});
+
+test("throws error when the second argument is not a string", () => {
+  expect(() => countChar("1234", 1)).toThrow(
+    "The argument for parameter findCharacter is not a String type"
+  );
+});
+
+test("throws error when second argument is longer than one character", () => {
+  expect(() => countChar("1234", "12")).toThrow(
+    "Parameter findCharacter is must contain a single character"
+  );
+});

Sprint-3/2-practice-tdd/get-ordinal-number.js

@@ -1,5 +1,28 @@
 function getOrdinalNumber(num) {
-  return "1st";
+  if (isNaN(num)) {
+    return "";
+  }
+
+  const numberString = String(num);
+  const lastDigit = Number(numberString.slice(-1));
+  const lastDigits = Number(numberString.slice(-2));
+  let ordinal;
+
+  if (num === 0) {
+    ordinal = "";
+  } else if ([11, 12, 13].includes(lastDigits)) {
+    ordinal = "th";
+  } else if (lastDigit === 1) {
+    ordinal = "st";
+  } else if (lastDigit === 2) {
+    ordinal = "nd";
+  } else if (lastDigit === 3) {
+    ordinal = "rd";
+  } else {
+    ordinal = "th";
+  }
+
+  return `${num}${ordinal}`;
 }
 
 module.exports = getOrdinalNumber;

Sprint-3/2-practice-tdd/get-ordinal-number.test.js

@@ -8,6 +8,62 @@ const getOrdinalNumber = require("./get-ordinal-number");
 // When the number is 1,
 // Then the function should return "1st"
 
-test("should return '1st' for 1", () => {
-  expect(getOrdinalNumber(1)).toEqual("1st");
+test("should return an empty string for a non-numerical character", () => {
+  expect(getOrdinalNumber("@")).toEqual("");
+});
+
+test("should return '0' for 0", () => {
+  expect(getOrdinalNumber(0)).toEqual("0");
+});
+
+test("should return '11th' for 11", () => {
+  expect(getOrdinalNumber(11)).toEqual("11th");
+});
+
+test("should return '12th' for 12", () => {
+  expect(getOrdinalNumber(12)).toEqual("12th");
+});
+
+test("should return '13th' for 13", () => {
+  expect(getOrdinalNumber(13)).toEqual("13th");
+});
+
+test("should return '-11th' for -11", () => {
+  expect(getOrdinalNumber(-11)).toEqual("-11th");
+});
+
+test("should return `22nd` for 22", () => {
+  expect(getOrdinalNumber(22)).toEqual("22nd");
+});
+
+test("should return `123rd` for 123", () => {
+  expect(getOrdinalNumber(123)).toEqual("123rd");
+});
+
+test("should return '1234th' for 1234", () => {
+  expect(getOrdinalNumber(1234)).toEqual("1234th");
+});
+
+test("should return '12345th' for 12345", () => {
+  expect(getOrdinalNumber(12345)).toEqual("12345th");
+});
+
+test("should return '123456th' for 123456", () => {
+  expect(getOrdinalNumber(123456)).toEqual("123456th");
+});
+
+test("should return '1234567th' for 1234567", () => {
+  expect(getOrdinalNumber(1234567)).toEqual("1234567th");
+});
+
+test("should return '12345678th' for 12345678", () => {
+  expect(getOrdinalNumber(12345678)).toEqual("12345678th");
+});
+
+test("should return '123456789th' for 123456789", () => {
+  expect(getOrdinalNumber(123456789)).toEqual("123456789th");
+});
+
+test("should return '1234567890' for 1234567890th", () => {
+  expect(getOrdinalNumber(1234567890)).toEqual("1234567890th");
 });

Sprint-3/2-practice-tdd/repeat.js

@@ -1,5 +1,15 @@
-function repeat() {
-  return "hellohellohello";
+function repeat(string, count) {
+  if (isNaN(count)) {
+    throw new Error("count is not a number");
+  } else if (count < 0) {
+    throw new Error("negative numbers are not valid");
+  } else if (count === 0) {
+    return "";
+  } else if (count === 1) {
+    return string;
+  } else {
+    return string.repeat(count);
+  }
 }
 
 module.exports = repeat;

Sprint-3/2-practice-tdd/repeat.test.js

@@ -21,12 +21,35 @@ test("should repeat the string count times", () => {
 // When the repeat function is called with these inputs,
 // Then it should return the original str without repetition, ensuring that a count of 1 results in no repetition.
 
+test("should repeat the string 1 times", () => {
+  const str = "Hello, World!";
+  const count = 1;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual(str);
+});
+
 // case: Handle Count of 0:
 // Given a target string str and a count equal to 0,
 // When the repeat function is called with these inputs,
 // Then it should return an empty string, ensuring that a count of 0 results in an empty output.
 
+test("should return an empty string for 0 times", () => {
+  const str = "Bye, World!";
+  const count = 0;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("");
+});
+
 // case: Negative Count:
 // Given a target string str and a negative integer count,
 // When the repeat function is called with these inputs,
 // Then it should throw an error or return an appropriate error message, as negative counts are not valid.
+
+test("should throw an error for a negative number", () => {
+  expect(() => repeat("Ello!", -1)).toThrow("negative numbers are not valid");
+});
+
+// case: count is not a number:
+test("should throw an error when count is not a number", () => {
+  expect(() => repeat("Hello?", "@")).toThrow("count is not a number");
+});

Sprint-3/3-stretch/credit-card-validator.js

@@ -0,0 +1,30 @@
+function creditCardValidator(cardNumber) {
+  // Check that the card number contains numbers only
+  if (isNaN(cardNumber)) return false;
+
+  // Convert the card number to a string so we can check its digits easily
+  let cardNumberString = String(cardNumber);
+
+  // Check that the card number has exactly 16 digits
+  if (cardNumberString.length != 16) return false;
+
+  // Check that the last digit is even
+  if (cardNumberString[15] % 2 != 0) return false;
+
+  // Calculate the sum of all digits
+  const sum = cardNumberString
+    .split("")
+    .reduce((sum, digit) => (sum += Number(digit)), 0);
+
+  // If the sum of all digits is 16 or less, the card is invalid
+  if (sum <= 16) return false;
+
+  // Use Set to filter out duplicate digits
+  let uniqueDigits = new Set(cardNumberString);
+
+  // Make sure the card number isn’t made up of all the same digit
+  if (uniqueDigits.size < 2) return false;
+
+  // If all conditions pass, the card number is valid
+  return true;
+}

Sprint-3/3-stretch/password-validator.js

@@ -1,6 +1,16 @@
+const previousPasswords = [];
+
 function passwordValidator(password) {
-    return password.length < 5 ? false : true
-}
+  if (previousPasswords.includes(password)) return false;
+  if (password.length < 5) return false;
+  if (!/[A-Z]/.test(password)) return false;
+  if (!/[a-z]/.test(password)) return false;
+  if (!/[0-9]/.test(password)) return false;
+  if (!/[!#$%.*&]/.test(password)) return false;
 
+  previousPasswords.push(password);
+
+  return true;
+}
 
-module.exports = passwordValidator;
+module.exports = passwordValidator;

Sprint-3/3-stretch/password-validator.test.js

@@ -15,12 +15,48 @@ To be valid, a password must:
 You must breakdown this problem in order to solve it. Find one test case first and get that working
 */
 const isValidPassword = require("./password-validator");
-test("password has at least 5 characters", () => {
-    // Arrange
-    const password = "12345";
-    // Act
-    const result = isValidPassword(password);
-    // Assert
-    expect(result).toEqual(true);
-}
-);
+
+test("invalid password (numbers only)", () => {
+  // Arrange
+  const password = "12345";
+  // Act
+  const result = isValidPassword(password);
+  // Assert
+  expect(result).toEqual(false);
+});
+
+test("invalid password (lowercase letters only)", () => {
+  const password = "abcde";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("invalid password (uppercase letters only)", () => {
+  const password = "QWERTY";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("invalid password (non-alphanumeric symbols only)", () => {
+  const password = "!#$%.*&!";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("valid password", () => {
+  const password = "aB1!cD";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});
+
+test("duplicate password", () => {
+  const password = "aB1!cD";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("new valid password", () => {
+  const password = "zX1$2£€";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});