Skip to content

Commit 2a98c5c

Browse files
gabriel-logangabriel-logan
committed
refactor: update type assertions in tests and improve linting scripts
1 parent 83dfbe8 commit 2a98c5c

37 files changed

+560
-427
lines changed

‎package.json

+2-2
Original file line numberDiff line numberDiff line change
@@ -22,8 +22,8 @@
2222
"build:src": "npx tsup index.ts --format esm --legacy-output",
2323
"build:browser": "webpack",
2424
"build": "yarn build:types && yarn build:browser",
25-
"lint": "eslint **/*.ts",
26-
"lint:fix": "eslint **/*.ts --fix",
25+
"lint": "eslint src/**/*.ts tests/**/*.ts",
26+
"lint:fix": "yarn lint --fix",
2727
"prettier": "prettier --write '**/*.{ts,js}'",
2828
"pr-check": "yarn prettier && yarn lint && yarn build && yarn test"
2929
},

‎src/cnpjValidator.ts

+3-4
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
import type { ValidateFunctions } from "./types";
2+
13
// Função para calcular o primeiro dígito verificador
24
function calculateFirstVerifier(cnpjBase: number[]): number {
35
const weight: Array<number> = [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
@@ -48,10 +50,7 @@ const defaultErrorMsg: string[] = [
4850
function cnpjIsValid(
4951
cnpj: string,
5052
errorMsg: (string | null)[] | null = defaultErrorMsg,
51-
): {
52-
isValid: boolean;
53-
errorMsg: string | null;
54-
} {
53+
): ValidateFunctions {
5554
if (typeof cnpj !== "string") {
5655
throw new TypeError("The input should be a string.");
5756
}

‎src/cpfValidator.ts

+3-4
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,5 @@
1+
import type { ValidateFunctions } from "./types";
2+
13
const defaultErrorMsg: string[] = [
24
"CPF invalid",
35
"CPF must have 11 numerical digits",
@@ -21,10 +23,7 @@ const defaultErrorMsg: string[] = [
2123
function cpfIsValid(
2224
cpf: string,
2325
errorMsg: (string | null)[] | null = defaultErrorMsg,
24-
): {
25-
isValid: boolean;
26-
errorMsg: string | null;
27-
} {
26+
): ValidateFunctions {
2827
if (typeof cpf !== "string") {
2928
throw new TypeError("The input should be a string.");
3029
}

‎src/validatePassword.ts

+2-2
Original file line numberDiff line numberDiff line change
@@ -122,7 +122,7 @@ function validatePassword(
122122
};
123123
}
124124

125-
function validateErrorMsg(errorMsg: (string | null)[] | undefined) {
125+
function validateErrorMsg(errorMsg: (string | null)[] | undefined): void {
126126
if (errorMsg) {
127127
if (!Array.isArray(errorMsg))
128128
throw new Error("errorMsg must be an Array or null");
@@ -139,7 +139,7 @@ function validateErrorMsg(errorMsg: (string | null)[] | undefined) {
139139
function validateLengthParams(
140140
minLenthPassword: number,
141141
maxLenthPassword: number,
142-
) {
142+
): void {
143143
if (
144144
typeof minLenthPassword !== "number" ||
145145
typeof maxLenthPassword !== "number"

‎tests/src/cnpjValidator.test.ts

+23-16
Original file line numberDiff line numberDiff line change
@@ -1,64 +1,68 @@
11
import cnpjIsValid from "../../src/cnpjValidator";
2+
import type { ValidateFunctions } from "../../src/types";
23

34
describe("cnpjIsValid function", () => {
45
test("should validate a valid CNPJ", () => {
5-
const result = cnpjIsValid("72.501.263/0001-40");
6+
const result: ValidateFunctions = cnpjIsValid("72.501.263/0001-40");
67
expect(result.isValid).toBe(false);
78
expect(result.errorMsg).toBe("CNPJ is not valid");
89
});
910

1011
test("should invalidate an invalid CNPJ", () => {
11-
const result = cnpjIsValid("12.345.678/0001-91");
12+
const result: ValidateFunctions = cnpjIsValid("12.345.678/0001-91");
1213
expect(result.isValid).toBe(false);
1314
expect(result.errorMsg).toBe("CNPJ is not valid");
1415
});
1516

1617
test("should invalidate a CNPJ with non-digit characters", () => {
17-
const result = cnpjIsValid("72.501.263/0001-4A");
18+
const result: ValidateFunctions = cnpjIsValid("72.501.263/0001-4A");
1819
expect(result.isValid).toBe(false);
1920
expect(result.errorMsg).toBe("CNPJ is not valid");
2021
});
2122

2223
test("should return false if cnpj length is not 14 or 18", () => {
23-
const result = cnpjIsValid("123456789012");
24+
const result: ValidateFunctions = cnpjIsValid("123456789012");
2425
expect(result.isValid).toBe(false);
2526
expect(result.errorMsg).toBe("CNPJ must have 14 numerical digits");
2627
});
2728

2829
test("should return false if cnpj has valid length but invalid verifier digits", () => {
29-
const result = cnpjIsValid("12.345.678/0001-00");
30+
const result: ValidateFunctions = cnpjIsValid("12.345.678/0001-00");
3031
expect(result.isValid).toBe(false);
3132
expect(result.errorMsg).toBe("CNPJ is not valid");
3233
});
3334

3435
test("should invalidate an empty CNPJ", () => {
35-
const result = cnpjIsValid("");
36+
const result: ValidateFunctions = cnpjIsValid("");
3637
expect(result.isValid).toBe(false);
3738
expect(result.errorMsg).toBe("CNPJ invalid");
3839
});
3940

4041
test("should throw an error if input is not a string", () => {
4142
expect(() => {
42-
cnpjIsValid(12345678901234 as any);
43+
cnpjIsValid(12345678901234 as unknown as string);
4344
}).toThrow("The input should be a string.");
4445
});
4546

4647
test("should throw an error if errorMsg is not an array", () => {
4748
expect(() => {
48-
cnpjIsValid("72.501.263/0001-40", "error message" as any);
49+
cnpjIsValid("72.501.263/0001-40", "error message" as unknown as string[]);
4950
}).toThrow("Must be an Array");
5051
});
5152

5253
test("should throw an error if errorMsg contains non-string values", () => {
5354
expect(() => {
54-
cnpjIsValid("72.501.263/0001-40", [123, "error message"] as any);
55+
cnpjIsValid("72.501.263/0001-40", [
56+
123,
57+
"error message",
58+
] as unknown as string[]);
5559
}).toThrow(
5660
"All values within the array must be strings or null/undefined.",
5761
);
5862
});
5963

6064
test("should return custom error messages", () => {
61-
const result = cnpjIsValid("12.345.678/0001-91", [
65+
const result: ValidateFunctions = cnpjIsValid("12.345.678/0001-91", [
6266
"Custom invalid message",
6367
"Custom length message",
6468
"Custom not valid message",
@@ -69,30 +73,33 @@ describe("cnpjIsValid function", () => {
6973
});
7074

7175
test("should return false when all digits are repeated", () => {
72-
const result = cnpjIsValid("11.111.111/1111-11");
76+
const result: ValidateFunctions = cnpjIsValid("11.111.111/1111-11");
7377
expect(result.isValid).toBe(false);
7478
expect(result.errorMsg).toBe("CNPJ is not valid");
7579
});
7680

7781
test("should return false when all digits are the same", () => {
78-
const result = cnpjIsValid("11.111.111/1111-11");
82+
const result: ValidateFunctions = cnpjIsValid("11.111.111/1111-11");
7983
expect(result.isValid).toBe(false);
8084
expect(result.errorMsg).toBe("CNPJ is not valid");
8185
});
8286

8387
test("should return default error messages when errorMsg['etc', null] is passed", () => {
84-
const result = cnpjIsValid("12.345.678/0001-91", ["etc", null]);
88+
const result: ValidateFunctions = cnpjIsValid("12.345.678/0001-91", [
89+
"etc",
90+
null,
91+
]);
8592
expect(result.errorMsg).toBe("CNPJ is not valid");
8693
});
8794

8895
test("should return default error messages when errorMsg is null", () => {
89-
const result = cnpjIsValid("12.345.678/0001-91", null);
96+
const result: ValidateFunctions = cnpjIsValid("12.345.678/0001-91", null);
9097
expect(result.errorMsg).toBe("CNPJ is not valid");
9198
});
9299

93100
test("should return true for a valid CNPJ where the first verifier is 0", () => {
94-
const cnpj = "69.228.768.0159-00";
95-
const result = cnpjIsValid(cnpj);
101+
const cnpj: string = "69.228.768.0159-00";
102+
const result: ValidateFunctions = cnpjIsValid(cnpj);
96103
expect(result.isValid).toBe(true);
97104
expect(result.errorMsg).toBeNull();
98105
});

‎tests/src/cpfValidator.test.ts

+18-17
Original file line numberDiff line numberDiff line change
@@ -1,87 +1,88 @@
11
import cpfIsValid from "../../src/cpfValidator";
2+
import type { ValidateFunctions } from "../../src/types";
23

34
describe("cpfIsValid", () => {
45
it("should return isValid as false and the correct error message when CPF is invalid", () => {
5-
const result = cpfIsValid("12345678902");
6+
const result: ValidateFunctions = cpfIsValid("12345678902");
67
expect(result.isValid).toBe(false);
78
expect(result.errorMsg).toBe("CPF is not valid");
89
});
910

1011
test("errorMessage should be default if pass an empty array", () => {
11-
const result = cpfIsValid("12345678902", []);
12+
const result: ValidateFunctions = cpfIsValid("12345678902", []);
1213
expect(result.isValid).toBe(false);
1314
});
1415

1516
test("errorMessage should be default if errorMsg[index] is falsy", () => {
16-
const result = cpfIsValid("12345678902", null);
17+
const result: ValidateFunctions = cpfIsValid("12345678902", null);
1718
expect(result.isValid).toBe(false);
1819
});
1920

2021
it("should return isValid as true and errorMsg as null when CPF is valid", () => {
21-
const result = cpfIsValid("12345678909");
22+
const result: ValidateFunctions = cpfIsValid("12345678909");
2223
expect(result.isValid).toBe(true);
2324
expect(result.errorMsg).toBe(null);
2425
});
2526

2627
it("should return isValid as false and the correct error message when CPF is invalid", () => {
27-
const result = cpfIsValid("123.456.789-02");
28+
const result: ValidateFunctions = cpfIsValid("123.456.789-02");
2829
expect(result.isValid).toBe(false);
2930
expect(result.errorMsg).toBe("CPF is not valid");
3031
});
3132

3233
it("should return isValid as true and errorMsg as null when CPF is valid", () => {
33-
const result = cpfIsValid("123.456.789-09");
34+
const result: ValidateFunctions = cpfIsValid("123.456.789-09");
3435
expect(result.isValid).toBe(true);
3536
expect(result.errorMsg).toBe(null);
3637
});
3738

3839
it("should return isValid as false and the correct error message when CPF is invalid", () => {
39-
const result = cpfIsValid("123456789-02");
40+
const result: ValidateFunctions = cpfIsValid("123456789-02");
4041
expect(result.isValid).toBe(false);
4142
expect(result.errorMsg).toBe("CPF is not valid");
4243
});
4344

4445
it("should throw an error when the input is not a string", () => {
45-
expect(() => cpfIsValid(12345678910 as any)).toThrow(
46+
expect(() => cpfIsValid(12345678910 as unknown as string)).toThrow(
4647
"The input should be a string.",
4748
);
4849
});
4950

5051
it("should throw an error when errorMsg is not an array", () => {
51-
expect(() => cpfIsValid("12345678910", "not an array" as any)).toThrow(
52-
"Must be an Array",
53-
);
52+
expect(() =>
53+
cpfIsValid("12345678910", "not an array" as unknown as string[]),
54+
).toThrow("Must be an Array");
5455
});
5556

5657
it("should throw an error when errorMsg contains non-string values", () => {
5758
expect(() =>
58-
cpfIsValid("12345678910", [123 as any, "error message"]),
59+
cpfIsValid("12345678910", [123 as unknown as string, "error message"]),
5960
).toThrow("All values within the array must be strings or null/undefined.");
6061
});
6162

6263
it("should throw an error when errorMsg contains non-string values", () => {
6364
expect(() =>
64-
cpfIsValid("12345678910", ["error message", 123 as any]),
65+
cpfIsValid("12345678910", ["error message", 123 as unknown as string]),
6566
).toThrow("All values within the array must be strings or null/undefined.");
6667
});
6768

6869
it("it should return false when all digits are repeated", () => {
69-
const result = cpfIsValid("11111111111");
70+
const result: ValidateFunctions = cpfIsValid("11111111111");
7071
expect(result.isValid).toBe(false);
7172
expect(result.errorMsg).toBe("CPF is not valid");
7273
});
7374

7475
it("should return isValid as false and the correct error message when CPF is null or empty", () => {
75-
const result = cpfIsValid("");
76+
const result: ValidateFunctions = cpfIsValid("");
7677
expect(result.isValid).toBe(false);
7778

78-
expect(() => cpfIsValid(null as any)).toThrow(
79+
expect(() => cpfIsValid(null as unknown as string)).toThrow(
7980
"The input should be a string.",
8081
);
8182
});
8283

8384
it("should return isValid as false and the correct error message when CPF does not have 11 digits after cleaning", () => {
84-
const result = cpfIsValid("123.456.789-0");
85+
const result: ValidateFunctions = cpfIsValid("123.456.789-0");
8586
expect(result.isValid).toBe(false);
8687
});
8788
});

0 commit comments

Comments
 (0)