London|26-ITP-January|Alexandru Pocovnicu|Sprint 3 |stretch

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

@@ -0,0 +1,13 @@
+function validateNumber(number) {
+  let arrNumber = [...number.toString()];
+
+  return arrNumber.length === 16 &&
+    arrNumber.every((x) => x >= "0" && x <= "9") &&
+    new Set(arrNumber).size > 1 &&
+    arrNumber[arrNumber.length - 1] % 2 === 0 &&
+    arrNumber.reduce((acc, cur) => +acc + +cur, 0) > 16
+    ? true
+    : false;
+}
+
+module.exports = validateNumber;

Sprint-3/4-stretch/card-validator.test.js

@@ -0,0 +1,50 @@
+const validateNumber = require("./card-validator")
+const isValidNumber=require("./card-validator")
+
+
+test("number should be 16 digits long",()=>{
+    expect(validateNumber(1029384756820562)).toEqual(true)
+})
+test("number should be 16 digits long", () => {
+  expect(validateNumber(10293847568202)).toEqual(false);
+});
+test("number should be 16 digits long", () => {
+  expect(validateNumber(1029384756820512348)).toEqual(false);
+});
+
+
+
+test("all digits must be numbers",()=>{
+    expect(validateNumber(1036294650361848)).toEqual(true)
+})
+test("all digits must be numbers", () => {
+  expect(validateNumber("103629465036184a")).toEqual(false);
+});
+
+
+
+test("all the digits can not be the same",()=>{
+    expect(validateNumber(3636363636363636)).toEqual(true)
+})
+test("all the digits can not be the same", () => {
+  expect(validateNumber(3333333333333336)).toEqual(true);
+});
+test("all the digits can not be the same", () => {
+  expect(validateNumber(2222222222222222)).toEqual(false);
+});
+
+
+test("the final digit must be even",()=>{
+    expect(validateNumber(1528056378293456)).toEqual(true)
+})
+test("the final digit must be even", () => {
+  expect(validateNumber(1528056378293457)).toEqual(false);
+});
+
+
+test("the sum of all digits must be greater than 16",()=>{
+    expect(validateNumber(1903647295628592)).toEqual(true)
+})
+test("the sum of all digits must be greater than 16", () => {
+  expect(validateNumber(1000100000000002)).toEqual(false);
+});

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

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

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

@@ -10,17 +10,73 @@ To be valid, a password must:
 - Have at least one English lowercase letter (a-z)
 - Have at least one number (0-9)
 - Have at least one of the following non-alphanumeric symbols: ("!", "#", "$", "%", ".", "*", "&")
-- Must not be any previous password in the passwords array. 
+- Must not be any previous password in the passwords array.  
 
 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";
+    const password = "12345Dpw%";
     // Act
     const result = isValidPassword(password);
     // Assert
     expect(result).toEqual(true);
 }
-);
+);
+test("password has at least 5 characters", () => {
+  const password = "1234";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+
+
+test("password has at least one English uppercase letter (A-Z)",()=>{
+    const password ="12345Aaoe$"
+    const result=isValidPassword(password)
+    expect(result).toEqual(true)
+
+});
+test("password has at least one English uppercase letter (A-Z)", () => {
+  const password = "12345";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+
+test("password has at least one English lower case letter (a-z)", () => {
+  const password = "S12345h#";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});
+test("password has at least one English lower case letter (a-z)", () => {
+  const password = "S12345P";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("password has at least one number (0-9)", () => {
+  const password = "123456Aa%";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});
+test("password has at least one number (0-9)", () => {
+  const password = "sgjjkdAa";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+test("password has at least one of the following non-alphanumeric symbols: (!, #, $, %, ., *, &)", () => {
+  const password = "123Spdfe!";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});
+test("password has at least one of the following non-alphanumeric symbols: (!, #, $, %, ., *, &)", () => {
+  const password = "123Spdfe";
+  const result = isValidPassword(password);
+  expect(result).toEqual(false);
+});
+
+
+//don't know how to check if the password was used before, do i need to create a passwords array?