feat: add password strength tester with customizable options and update tests

Author: gabriel-logan

index.ts

@@ -33,6 +33,11 @@ import isValidPdf from "./src/isValidPdf";
 import isValidVideo from "./src/isValidVideo";
 import isValidTxt from "./src/isValidTxt";
 import type { ValidateFunctions, IsValidFunctions } from "./src/types";
+import type {
+	PasswordStrengthTesterOptions,
+	PasswordStrengthFunction,
+	PasswordStrengthType,
+} from "./src/passwordStrengthTester";
 
 export {
 	cpfIsValid,
@@ -108,4 +113,10 @@ export default {
 	isValidTxt,
 };
 
-export type { ValidateFunctions, IsValidFunctions };
+export type {
+	ValidateFunctions,
+	IsValidFunctions,
+	PasswordStrengthTesterOptions,
+	PasswordStrengthFunction,
+	PasswordStrengthType,
+};

src/passwordStrengthTester.ts

@@ -1,142 +1,90 @@
+export type PasswordStrengthType =
+	| "Very weak"
+	| "Weak"
+	| "Regular"
+	| "Strong"
+	| "Very strong"
+	| "Not classified";
+
+export type PasswordStrengthFunction = (
+	password: string,
+	passwordLength: number,
+) => boolean;
+
+export interface PasswordStrengthTesterOptions {
+	isVeryWeak: PasswordStrengthFunction;
+	isWeak: PasswordStrengthFunction;
+	isRegular: PasswordStrengthFunction;
+	isStrong: PasswordStrengthFunction;
+	isVeryStrong: PasswordStrengthFunction;
+}
+
 /**
- * @description Avalia a força de uma senha e retorna o tipo de força da senha.
- *
- * @returns O tipo de força da senha ('veryWeak', 'weak', 'regular', 'strong' ou 'veryStrong').
- *
- * @example
- * passwordStrengthTester('12345'); // Output: 'veryWeak'
- *
- * @example
- * passwordStrengthTester('abcdef'); // Output: 'weak'
+ * @param password - The password to test
+ * @param Options - An object containing functions to test the password strength
+ * @param Options.isVeryWeak - A function to test if the password is very weak
+ * @param Options.isWeak - A function to test if the password is weak
+ * @param Options.isRegular - A function to test if the password is regular
+ * @param Options.isStrong - A function to test if the password is strong
+ * @param Options.isVeryStrong - A function to test if the password is very strong
+ * @throws {TypeError} - If the input is not a string
  *
  * @example
- * passwordStrengthTester('abc12345'); // Output: 'regular'
+ * const options = {
+ * 	isVeryWeak: (password, passwordLength) => passwordLength < 6,
+ * 	isWeak: (password, passwordLength) => passwordLength < 8,
+ * 	isRegular: (password, passwordLength) => passwordLength < 10,
+ * 	isStrong: (password, passwordLength) => passwordLength < 12,
+ * 	isVeryStrong: (password, passwordLength) => passwordLength >= 12,
+ * }
  *
- * @example
- * passwordStrengthTester('Abc123awdasd'); // Output: 'strong'
- *
- * @example
- * passwordStrengthTester('SuperSecurePassword123!@'); // Output: 'veryStrong'
+ * passwordStrengthTester("12345", options); // Very weak
+ * passwordStrengthTester("1234567", options); // Weak
+ * @returns {string}
  */
-function passwordStrengthTester(password: string): string {
+function passwordStrengthTester(
+	password: string,
+	{
+		isVeryWeak,
+		isWeak,
+		isRegular,
+		isStrong,
+		isVeryStrong,
+	}: PasswordStrengthTesterOptions,
+): string {
 	if (typeof password !== "string") {
 		throw new TypeError("The input should be a string.");
 	}
 	const passwordLength: number = password.length;
-	let strengthType: string;
+	let strengthType: PasswordStrengthType;
 
 	switch (true) {
-		case isVeryWeak(password, passwordLength) || commonPassword(password):
-			strengthType = "veryWeak";
+		case isVeryWeak(password, passwordLength):
+			strengthType = "Very weak";
 			break;
 
 		case isWeak(password, passwordLength):
-			strengthType = "weak";
+			strengthType = "Weak";
 			break;
 
 		case isRegular(password, passwordLength):
-			strengthType = "regular";
-			break;
-
-		case isVeryStrong(password, passwordLength):
-			strengthType = "veryStrong";
+			strengthType = "Regular";
 			break;
 
 		case isStrong(password, passwordLength):
-			strengthType = "strong";
+			strengthType = "Strong";
 			break;
 
-		case isRegular2(password, passwordLength):
-			strengthType = "regular";
+		case isVeryStrong(password, passwordLength):
+			strengthType = "Very strong";
 			break;
 
 		default:
-			strengthType = "not classified";
+			strengthType = "Not classified";
 			break;
 	}
 
 	return strengthType;
 }
 
-function isVeryWeak(password: string, passwordLength: number): boolean {
-	return passwordLength <= 5 && /^\d+$/.test(password);
-}
-
-function isWeak(password: string, passwordLength: number): boolean {
-	return (
-		(passwordLength <= 5 && /^[a-zA-Z0-9]+$/.test(password)) ||
-		(passwordLength >= 6 &&
-			/^[a-zA-Z0-9]+$/.test(password) &&
-			passwordLength <= 7) ||
-		(passwordLength < 10 && /(.)\1{3,}/.test(password)) ||
-		(passwordLength >= 5 && passwordLength <= 8 && /^\d+$/.test(password))
-	);
-}
-
-function isRegular(password: string, passwordLength: number): boolean {
-	return /(.)\1{5,}/.test(password) && passwordLength > 10;
-}
-
-function isVeryStrong(password: string, passwordLength: number): boolean {
-	return (
-		passwordLength > 16 ||
-		(password.length >= 8 &&
-			/[A-Z]/.test(password) &&
-			/[a-z]/.test(password) &&
-			/\d/.test(password) &&
-			/[\W_]/.test(password))
-	);
-}
-
-function isRegular2(password: string, passwordLength: number): boolean {
-	return (
-		(passwordLength >= 9 && passwordLength <= 12) ||
-		(password.length >= 6 &&
-			password.length <= 8 &&
-			/\d/.test(password) &&
-			/[a-zA-Z]/.test(password))
-	);
-}
-
-function isStrong(password: string, passwordLength: number): boolean {
-	return (
-		(passwordLength >= 13 && passwordLength <= 16) ||
-		(password.length >= 8 &&
-			/[A-Z]/.test(password) &&
-			/[a-z]/.test(password) &&
-			/\d/.test(password))
-	);
-}
-
-function commonPassword(password: string): boolean {
-	const commonPasswords: string[] = [
-		"123",
-		"1234",
-		"12345",
-		"123456",
-		"1234567",
-		"12345678",
-		"123456789",
-		"password",
-		"password",
-		"password!",
-		"password!1",
-		"admin",
-		"admin!",
-		"Admin",
-		"Admin!",
-		"admin123",
-		"P@ssw0rd",
-		"Password",
-		"password123",
-		"password123!",
-		"Qwerty",
-		"Qwerty!",
-		"Qwerty123",
-		"Qwerty123!",
-	];
-
-	return commonPasswords.includes(password);
-}
-
 export default passwordStrengthTester;

tests/src/passwordStrengthTester.test.ts

@@ -1,18 +1,60 @@
 import { passwordStrengthTester } from "../../index";
+import { PasswordStrengthTesterOptions } from "../../src/passwordStrengthTester";
 
 describe("passwordStrengthTester function", () => {
+	let options: PasswordStrengthTesterOptions;
+
+	beforeEach(() => {
+		options = {
+			isVeryWeak: (password: string, passwordLength: number) => {
+				return passwordLength < 6 && password === "12345";
+			},
+			isWeak: (password: string, passwordLength: number) => {
+				return passwordLength < 8 && password === "1234567";
+			},
+			isRegular: (password: string, passwordLength: number) => {
+				return passwordLength < 10 && password === "123456789";
+			},
+			isStrong: (password: string, passwordLength: number) => {
+				return passwordLength < 12 && password === "12345678910";
+			},
+			isVeryStrong: (password: string, passwordLength: number) => {
+				return passwordLength >= 12 && password === "1234567891011";
+			},
+		};
+	});
+
 	it("should throw an error if the input is not a string", () => {
-		expect(() => passwordStrengthTester(123 as any)).toThrow(
+		expect(() => passwordStrengthTester(123 as any, {} as any)).toThrow(
 			"The input should be a string.",
 		);
 	});
-	test("should return correct strength type", () => {
-		expect(passwordStrengthTester("12345")).toBe("veryWeak");
-		expect(passwordStrengthTester("abcdef")).toBe("weak");
-		expect(passwordStrengthTester("abc12345")).toBe("regular");
-		expect(passwordStrengthTester("Abc123awdasd")).toBe("strong");
-		expect(passwordStrengthTester("SuperSecurePassword123!@")).toBe(
-			"veryStrong",
+
+	it("should return 'Very weak' if the password is very weak", () => {
+		expect(passwordStrengthTester("12345", options)).toBe("Very weak");
+	});
+
+	it("should return 'Weak' if the password is weak", () => {
+		expect(passwordStrengthTester("1234567", options)).toBe("Weak");
+	});
+
+	it("should return 'Regular' if the password is regular", () => {
+		expect(passwordStrengthTester("123456789", options)).toBe("Regular");
+	});
+
+	it("should return 'Strong' if the password is strong", () => {
+		expect(passwordStrengthTester("12345678910", options)).toBe("Strong");
+	});
+
+	it("should return 'Very strong' if the password is very strong", () => {
+		expect(passwordStrengthTester("1234567891011", options)).toBe(
+			"Very strong",
+		);
+	});
+
+	it("should return 'Not classified' if the password is not classified", () => {
+		expect(passwordStrengthTester("123456789101112", options)).toBe(
+			"Not classified",
 		);
 	});
 });

tests/src/validateUsername.test.ts

@@ -46,9 +46,7 @@ describe("validateUsername", () => {
 				maxLength: 25,
 				errorMsg: ["Error message", 123] as any,
 			}),
-		).toThrow(
-			"All values within the array must be strings or null/undefined.",
-		);
+		).toThrow("All values within the array must be strings or null/undefined.");
 	});
 
 	it("should throw an error if minLength or maxLength is less than 1", () => {

tests/testerGeral.test.ts

@@ -23,7 +23,6 @@ import {
 	validateUSPhoneNumber,
 	validatePhoneNumber,
 	isNumber,
-	passwordStrengthTester,
 	validateName,
 	validateSurname,
 	validateTextarea,
@@ -152,11 +151,6 @@ describe("Testes para as funções de validação", () => {
 		expect(isNumber("NotANumber")).toBe(false);
 	});
 
-	test("passwordStrengthTester should assess password strength correctly", () => {
-		expect(passwordStrengthTester("Password123")).toBe("strong");
-		expect(passwordStrengthTester("weak")).toBe("weak");
-	});
-
 	test("validateName should validate names correctly", () => {
 		expect(validateName("John").isValid).toBe(true);
 		expect(validateName("InvalidName@").isValid).toBe(false);