Password validator jan 10 1

ThePhasesOfCraftship/2_best_practice_first/testingBasics/exercises/2_Arrange_Act_Assert_Backwards/2_1_Password_Validator/src/index.spec.ts

@@ -1,8 +1,55 @@
+import {
+  Checked,
+  lengthRestrictionError,
+  numberRestrictionError,
+  PasswordValidator, PasswordValidatorError,
+  uppercaseRestrictionError
+} from "./index";
+
+
+const length = 'length';
+const number = 'number';
+const uppercase = 'uppercase';
 
 describe('password validator', () => {
 
-  test('hello', () => {
-    expect("between 5 and 15").toContain('5 and 15')
+  const falsyCases: [string, string, PasswordValidatorError][] = [
+      ['aA1', length, lengthRestrictionError],
+      ['abcdefFGhi12345678', length, lengthRestrictionError],
+      ['abCde', number, numberRestrictionError],
+      ['1bcde', uppercase, uppercaseRestrictionError],
+      ['maxwell1_c', uppercase, uppercaseRestrictionError],
+      ['maxwellTheBe', number, numberRestrictionError],
+      ['thePhysical1234567', length, lengthRestrictionError],
+  ]
+
+  test.each(falsyCases)('should know that \"%s\" is not valid regarding to %s policy', (input, policy, error) => {
+    const result = PasswordValidator.check(input);
+    expect(result).toHaveProperty('result')
+    expect(result).toHaveProperty('errors')
+    expect(result.errors).toContainEqual(error)
+    expect(result.result).toBeFalsy()
+  })
+
+  const truthyCases: [string, string][] = [
+      ['abc1E', length ],
+      ['abc1E', number ],
+      ['1bcdE', uppercase]
+  ]
+
+  test.each(truthyCases)('should know that \"%s\" is valid regarding to %s policy', (password, policy) => {
+    const result = PasswordValidator.check(password);
+    expect(result).toHaveProperty('result')
+    expect(result.errors).toBe(undefined)
+    expect(result.result).toBeTruthy()
+  })
+
+  it('should show three errors for \"abc\" password', () => {
+      const result = PasswordValidator.check('abc');
+      expect(result).toHaveProperty('result')
+      expect(result).toHaveProperty('errors')
+      expect(result.errors).toHaveLength(3)
+      expect(result.result).toBeFalsy()
   })
 })
 

ThePhasesOfCraftship/2_best_practice_first/testingBasics/exercises/2_Arrange_Act_Assert_Backwards/2_1_Password_Validator/src/index.ts

@@ -0,0 +1,66 @@
+export type Checked = {
+    result: boolean,
+    errors?: PasswordValidatorError[]
+};
+
+export const PasswordErrors = {
+    numberOfCharacters: {
+        type: 'numberOfCharacters',
+        message: 'Should be in between 5 and 15 characters long',
+    },
+    missingNumber: {
+        type: 'missingNumber',
+        message: 'Should contain at least one numeric character',
+    },
+    missingUppercase: {
+        type: 'missingUppercase',
+        message: 'Should contain at least one uppercase letter',
+    },
+} as const;
+
+export type PasswordErrorType = keyof typeof PasswordErrors;
+export type PasswordErrorMessage = typeof PasswordErrors[PasswordErrorType]['message'];
+
+export const lengthRestrictionError = PasswordErrors.numberOfCharacters;
+export const numberRestrictionError = PasswordErrors.missingNumber;
+export const uppercaseRestrictionError = PasswordErrors.missingUppercase;
+
+export type PasswordValidatorError = {
+    type: PasswordErrorType;
+    message: PasswordErrorMessage;
+};
+
+export class PasswordValidator {
+    static check(password: string): Checked {
+        const checked: Checked = {
+            result: true
+        }
+        let errors: PasswordValidatorError[] = [];
+        if(this.isNotBetween5And15(password)) {
+            errors.push(lengthRestrictionError)
+        }
+        if(this.hasNoDigits(password)) {
+            errors.push(numberRestrictionError)
+        }
+        if(this.hasNoUppercase(password)) {
+            errors.push(uppercaseRestrictionError)
+        }
+        if (errors.length) {
+            checked.result = false
+            checked.errors = errors
+        }
+        return checked;
+    }
+
+    private static isNotBetween5And15(password: string) {
+        return password.length < 5 || password.length > 15;
+    }
+
+    private static hasNoDigits(password: string) {
+        return !/\d/.test(password);
+    }
+
+    private static hasNoUppercase(password: string) {
+        return !/[A-Z]/.test(password);
+    }
+}