validation-br 1.5.2 → 1.6.0

package/test/nup17.test.ts

@@ -0,0 +1,127 @@
+import isNUP17, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/nup17';
+import * as _nup17 from '../src/nup17';
+
+describe('NUP17', () => {
+  test.each([
+    // Masked
+    '23037.001380/2021-11',
+    '23037.001434/2021-48',
+    '23037.001321/2021-42',
+    // String
+    '23037001462202165',
+    '23037001537202116',
+    '23037001086202117',
+  ])('isNUP17() - Números válidos', (item) => {
+
+    expect(isNUP17(item)).toBeTruthy();
+    expect(_nup17.validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    // Masked
+    '23037.001380/2021-11',
+    '23037.001434/2021-48',
+    '23037.001321/2021-42',
+    // String
+    '23037001462202165',
+    '23037001537202116',
+    '23037001086202117',
+  ])('validate() - Números válidos', (item) => {
+
+    expect(validate(item)).toBeTruthy();
+
+  });
+
+  test.each([
+    // Masked
+    '23037001380202112',
+    '23037001434202142',
+    '23037001462202162',
+    '23037001537202112',
+  ])('validate() - Números inválidos', (item) => {
+
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    // Masked
+    '23037001380202112',
+    '23037001434202142',
+    '23037001462202162',
+    '23037001537202112',
+  ])('validateOrFail() - Números inválidos', (item) => {
+
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test.each([
+    // Números válidos com 1 caractere a mais no final
+    '230370014622021650',
+    '230370015372021160',
+    '230370010862021170',
+  ])('validateOrFail() - Números válidos com caracteres adicionais', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isNUP17('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const nup17 = fake();
+    expect(validate(nup17)).toBeTruthy();
+    expect(nup17).toHaveLength(17);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const nup17 = fake(true);
+    expect(validate(nup17)).toBeTruthy();
+    expect(nup17).toHaveLength(20);
+  });
+
+  test.each([
+    { num: '23037.001380/2021', expected: '11' },
+    { num: '23037.001434/2021', expected: '48' },
+    { num: '23037.001321/2021', expected: '42' },
+    { num: '230370014622021', expected: '65' },
+    { num: '230370015372021', expected: '16' },
+    { num: '230370010862021', expected: '17' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.num);
+
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { value: '23037001380202111', expected: '23037.001380/2021-11' },
+    { value: '23037001434202148', expected: '23037.001434/2021-48' },
+    { value: '23037001321202142', expected: '23037.001321/2021-42' },
+    { value: '23037001462202165', expected: '23037.001462/2021-65' },
+    { value: '23037001537202116', expected: '23037.001537/2021-16' },
+    { value: '23037001086202117', expected: '23037.001086/2021-17' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(20);
+  });
+
+  test.each([
+    { value: '23037.001380/2021-11', expected: '23037001380202111', },
+    { value: '23037.001434/2021-48', expected: '23037001434202148', },
+    { value: '23037.001321/2021-42', expected: '23037001321202142', },
+    { value: '23037.001462/2021-65', expected: '23037001462202165', },
+    { value: '23037.001537/2021-16', expected: '23037001537202116', },
+    { value: '23037.001086/2021-17', expected: '23037001086202117', },
+  ])('normalize() - Deve remover a máscara corretamente', (item) => {
+
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(17);
+  });
+});

package/test/pisPasep.test.ts

@@ -0,0 +1,126 @@
+import isPIS, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/pisPasep';
+import * as _pisPasep from '../src/pisPasep';
+
+describe('PIS', () => {
+  test.each([
+    // string
+    '71282677380',
+    '23795126955',
+    // integer
+    50012973803,
+    27890141144,
+    // masked
+    '268.27649.96-0',
+    '613.01862.91-7',
+  ])('isPIS() - Números válidos', (item) => {
+    expect(isPIS(item)).toBeTruthy();
+    expect(_pisPasep.validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    // string
+    '71282677380',
+    '23795126955',
+    // integer
+    50012973803,
+    27890141144,
+    // masked
+    '268.27649.96-0',
+    '613.01862.91-7',
+  ])('validate() - Números válidos', (item) => {
+
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    // string
+    '712826773809',
+    '237951269559',
+    // integer
+    500129738039,
+    278901411449,
+    // masked
+    '268.27649.96-09',
+    '613.01862.91-79',
+  ])('validate() - Números válidos com caracteres adicionais', (item) => {
+
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    '712.82677.38-2',
+    '237.95126.95-4',
+    '500.12973.80-1',
+    '278.90141.14-9',
+    '268.27649.96-2',
+    '613.01862.91-4',
+    '111.11111.11-1',
+  ])('validate() - Números inválidos', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    '712.82677.38-2',
+    '237.95126.95-4',
+    '500.12973.80-1',
+    '278.90141.14-9',
+    '268.27649.96-2',
+    '613.01862.91-4',
+    '111.11111.11-1',
+  ])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isPIS('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const pis = fake();
+    expect(validate(pis)).toBeTruthy();
+    expect(pis).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const pis = fake(true);
+    expect(validate(pis)).toBeTruthy();
+    expect(pis).toHaveLength(14);
+
+  });
+
+  test.each([
+    { value: '7128267738', expected: '0' },
+    { value: 2379512695, expected: '5' },
+    { value: '5001297380', expected: '3' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.value);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+
+  });
+
+  test.each([
+    { value: '71282677380', expected: '712.82677.38-0' },
+    { value: 23795126955, expected: '237.95126.95-5' },
+    { value: '50012973803', expected: '500.12973.80-3' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(14);
+  });
+
+  test.each([
+    { value: '712.82677.38-0', expected: '71282677380', },
+    { value: '237.95126.95-5', expected: '23795126955', },
+    { value: '500.12973.80-3', expected: '50012973803', },
+  ])('normalize() - Deve remover a máscara corretamente', (item) => {
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(11);
+  });
+});

package/test/postalCode.test.ts

@@ -0,0 +1,114 @@
+import isPostalCode, { dv, fake, normalize, mask, validate, validateOrFail } from '../src/postalCode';
+import * as _postalCode from '../src/postalCode';
+
+describe('PostalCode', () => {
+  test.each([
+    'PN718252423BR',
+    'PO925539762BR',
+    'JT194690698BR',
+    'SV143851674BR',
+    'RG727348650CN',
+    'RY747622885CN',
+    'RY728187035CN',
+    'RH940629235CN',
+    'RY686586175CN',
+    'RY648001205CN',
+    'UJ776469464CN',
+    'LZ667841882CN',
+    'RS737783818NL',
+  ])('isPostalCode() - Números válidos', (item) => {
+
+    expect(isPostalCode(item)).toBeTruthy();
+    expect(_postalCode.validate(item)).toBeTruthy();
+
+  });
+
+  test.each([
+    'PN718252423BR',
+    'PO925539762BR',
+    'JT194690698BR',
+    'SV143851674BR',
+    'RG727348650CN',
+    'RY747622885CN',
+    'RY728187035CN',
+    'RH940629235CN',
+    'RY686586175CN',
+    'RY648001205CN',
+    'UJ776469464CN',
+    'LZ667841882CN',
+    'RS737783818NL',
+  ])('validate() - Números válidos', (item) => {
+
+    expect(validate(item)).toBeTruthy();
+
+  });
+
+  test.each([
+    'PO925524762BR',
+    'JT194624698BR',
+    'SV143824674BR',
+    'RG727324650CN',
+    'RY747624885CN',
+    'RY728114035CN',
+  ])('validate() - Números inválidos', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    'PO925524762BR',
+    'JT194624698BR',
+    'SV143824674BR',
+    'RG727324650CN',
+    'RY747624885CN',
+    'RY728114035CN',
+  ])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isPostalCode('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes corretamente', () => {
+    const postalCode = fake();
+
+    expect(validate(postalCode)).toBeTruthy();
+    expect(postalCode).toHaveLength(13);
+  });
+
+  test.each([
+    { value: 'PN718252423BR', expected: '3' },
+    { value: 'PO925539762BR', expected: '2' },
+    { value: 'JT194690698BR', expected: '8' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.value);
+
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { value: 'pn718252423br', expected: 'PN718252423BR' },
+    { value: 'po925539762br', expected: 'PO925539762BR' },
+    { value: 'jt194690698br', expected: 'JT194690698BR' },
+  ])('normalize() - Deve normalizar o valor inicial corretamente', (item) => {
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(13);
+  });
+
+  test.each([
+    { value: 'pn718252423br', expected: 'PN718252423BR' },
+    { value: 'po925539762br', expected: 'PO925539762BR' },
+    { value: 'jt194690698br', expected: 'JT194690698BR' },
+  ])('mask() - Deve normalizar o valor inicial corretamente', (item) => {
+    const masked = mask(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(13);
+  });
+});

package/test/renavam.test.ts

@@ -0,0 +1,77 @@
+import isRenavam, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/renavam';
+
+
+describe('Renavam', () => {
+  test.each([
+    // valores com máscara
+    '1952519770-3',
+    '3394038959-9',
+    // valores como inteiros
+    3607626105,
+    64090416160,
+    // valores como string sem máscara
+    '80499688374',
+    '40650543741',
+  ])('isRenavam() - %s deve ser um renavam válido', (renavam) => {
+    expect(isRenavam(renavam)).toBeTruthy();
+    expect(validate(renavam)).toBeTruthy();
+    expect(validateOrFail(renavam)).toBeTruthy();
+  });
+
+  test.each(['19525227703', '33940229599', '03607226105', '64090226160', '80499228374'])(
+    'validate() - Números inválidos',
+    (renavam) => {
+      expect(validate(renavam)).toBeFalsy();
+      expect(() => validateOrFail(renavam)).toThrow();
+    },
+  );
+
+  test('Parâmetro não informado', () => {
+    expect(isRenavam('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const renavam = fake();
+    expect(validate(renavam)).toBeTruthy();
+    expect(renavam).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const renavam = fake(true);
+    expect(validate(renavam)).toBeTruthy();
+    expect(renavam).toHaveLength(12);
+  });
+
+  test.each([
+    { value: '1952519770', expected: '3' },
+    { value: 952519770, expected: '6' },
+    { value: 52519770, expected: '2' },
+  ])('renavam.dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.value);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { value: '19525197703', expected: '1952519770-3' },
+    { value: 9525197703, expected: '0952519770-3' },
+    { value: 525197703, expected: '0052519770-3' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(12);
+  });
+
+  test.each([
+    { value: '1952519770-3', expected: '19525197703', },
+    { value: '0952519770-3', expected: '09525197703', },
+    { value: '0052519770-3', expected: '00525197703', },
+  ])('normalize() - Deve remover a máscara corretamente', (item) => {
+    const normalized = normalize(item.value);
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(11);
+  });
+});

package/test/tituloEleitor.test.ts

@@ -0,0 +1,110 @@
+import isTituloEleitor, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/tituloEleitor';
+
+describe('TituloEleitor', () => {
+  test.each([
+    // masked
+    '1023.8501.0671',
+    '8365 7137 1619',
+    // string
+    '153036161686',
+    '525028881694',
+    // integer
+    13132331643,
+    1122221333,
+  ])('isTituloEleitor() - Números válidos', (item) => {
+    expect(isTituloEleitor(item)).toBeTruthy();
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test('Deve rejeitar quando a UF for maior que 28', () => {
+    const titulo = '1122 3344 2992';
+    expect(validate(titulo)).toBeFalsy();
+    // expect(() => validateOrFail(titulo)).toThrow()
+  });
+
+  test.each([
+    '836531371619',
+    '743620641660',
+    '153016161686',
+    '525078881694',
+    '026367681660',
+    '558647441635',
+    '222222222222',
+  ])('validate() - Números inválidos', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    '836531371619',
+    '743620641660',
+    '153016161686',
+    '525078881694',
+    '026367681660',
+    '558647441635',
+    '222222222222',
+  ])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isTituloEleitor('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const tituloEleitor = fake();
+
+    expect(validate(tituloEleitor)).toBeTruthy();
+    expect(tituloEleitor).toHaveLength(12);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const tituloEleitor = fake(true);
+
+    expect(validate(tituloEleitor)).toBeTruthy();
+    expect(tituloEleitor).toHaveLength(14);
+  });
+
+  test.each([
+    { value: '1023850106', expected: '71' },
+    { value: '8365713716', expected: '19' },
+    { value: '7436506416', expected: '60' },
+    { value: '0011222213', expected: '33' },
+  ])('dv() - Verificando se o DV gerado está correto', (item) => {
+    const calcDv = dv(item.value);
+
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+  test.each([
+    { value: '102385010671', expected: '1023.8501.0671' },
+    { value: '836571371619', expected: '8365.7137.1619' },
+    { value: '743650641660', expected: '7436.5064.1660' },
+    { value: 11122223360, expected: '0111.2222.3360' },
+    { value: 1122223336, expected: '0011.2222.3336' },
+  ]
+
+  )('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(14);
+  });
+
+  test.each([
+    { value: '1023.8501.0671', expected: '102385010671', },
+    { value: '8365.7137.1619', expected: '836571371619', },
+    { value: '7436.5064.1660', expected: '743650641660', },
+    { value: '0111.2222.3360', expected: '011122223360', },
+    { value: '0011.2222.3336', expected: '001122223336', },
+  ]
+  )('normalize() - Deve remover a máscara corretamente', (item) => {
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(12);
+  });
+});

package/test/utils-applyMask.test.ts

@@ -0,0 +1,13 @@
+import { applyMask } from '../src/utils';
+
+describe('applyMask()', () => {
+  test.each([
+    { value: '123456', mask: '00000-0', expected: '12345-6' },
+    { value: '12345', mask: '00000-0', expected: '01234-5' },
+    { value: '123456789', mask: '00000-0', expected: '12345-6' },
+    { value: 123456789, mask: '00000-0', expected: '12345-6' },
+  ])('Máscara deve ser aplicada com o valor e tamanho correto', (item) => {
+    expect(item.expected.length).toBe(item.mask.length);
+    expect(applyMask(item.value, item.mask)).toBe(item.expected);
+  });
+});

package/test/utils-checkRepeatedSequence.test.ts

@@ -0,0 +1,17 @@
+import { checkRepeatedSequence } from "../src/utils";
+
+test.each([
+  '11111111',
+  '1111',
+])('testa se %s tem todos os valores iguais', (value) => {
+  expect(checkRepeatedSequence(value)).toBeTruthy();
+});
+
+test.each([
+  '12345678',
+  '11111112',
+  '1234',
+  '2111',
+])('testa se %s não tem todos os valores iguais', (value) => {
+  expect(checkRepeatedSequence(value)).toBeFalsy();
+});

package/test/utils-clearValue.test.ts

@@ -0,0 +1,69 @@
+import { clearValue } from '../src/utils';
+
+describe('clearValue()', () => {
+  test.each([
+    { value: 1234567890, size: 10, expected: '1234567890' },
+    { value: '1234567890', size: 10, expected: '1234567890' },
+    { value: '12.345.678-90', size: 10, expected: '1234567890' },
+    { value: '1234 5678 9012', size: 10, expected: '123456789012' },
+  ]
+  )('Deve limpar o valor - Strings do Mesmo tamanho', (item) => {
+    expect(clearValue(item.value, item.size)).toBe(item.expected);
+  });
+
+  test.each([
+    { value: 1234567890123, size: null, expected: '1234567890123' },
+    { value: '4567890', size: null, expected: '4567890' },
+    { value: '345.678-90', size: null, expected: '34567890' },
+  ])('Deve limpar os caracteres não numéricos sem verificar o tamanho da string', (item) => {
+    expect(clearValue(item.value, item.size)).toBe(item.expected);
+  });
+
+  test.each([
+    { value: 1234, size: 10, expected: '0000001234' },
+    { value: '1234', size: 10, expected: '0000001234' },
+    { value: '123-4', size: 10, expected: '0000001234' },
+  ])('Deve limpar o valor os caracteres não numéricos e completar com zeros à esquerda', (item) => {
+    expect(clearValue(item.value, item.size, { fillZerosAtLeft: true })).toBe(item.expected);
+  });
+
+  // Não completa com zeros
+  expect(clearValue(1234, 6, { fillZerosAtLeft: false })).toBe('1234');
+  expect(clearValue('1234', 6, { fillZerosAtLeft: false })).toBe('1234');
+
+  test.each([
+    { value: 123456789, size: 4, expected: '1234' },
+    { value: '1234567890', size: 4, expected: '1234' },
+    { value: '12.345.678-90', size: 4, expected: '1234' },
+  ])('Deve limpar o valor os caracteres não numéricos e remover os caracteres que passarem de size', (item) => {
+    expect(clearValue(item.value, item.size, { trimAtRight: true })).toBe(item.expected);
+  });
+
+  // Não corta à direita
+  expect(clearValue(12345678, 6, { trimAtRight: false })).toBe('12345678');
+  expect(clearValue('12345678', 6, { trimAtRight: false })).toBe('12345678');
+
+
+
+  test('Deve retornar erro se receber um valor vazio', () => {
+    expect(clearValue('1112', 4, { rejectEmpty: true })).toBe('1112');
+    expect(() => clearValue('', null, { rejectEmpty: true })).toThrow();
+  });
+
+  test('Deve retornar erro se receber uma sequência de números iguais', () => {
+    expect(clearValue('1112', 4, { rejectEqualSequence: true })).toBe('1112');
+    expect(() => clearValue('1111', 4, { rejectEqualSequence: true })).toThrow();
+  });
+
+  test('Deve retornar erro se receber um valor com mais caracteres que o máximo', () => {
+    expect(clearValue('1234', 4, { rejectHigherLength: true })).toBe('1234');
+    expect(() => clearValue('12345', 4, { rejectHigherLength: true })).toThrow();
+  });
+
+  test('Deve retornar o mesmo valor inicial', () => {
+    expect(clearValue(1234, 4)).toBe('1234');
+    expect(clearValue('1234', 4)).toBe('1234');
+    expect(clearValue(1234, 4, {})).toBe('1234');
+    expect(clearValue('1234', 4, {})).toBe('1234');
+  });
+});

package/test/utils-fakeNumber.test.ts

@@ -0,0 +1,28 @@
+import { fakeNumber } from '../src/utils';
+
+describe('fakeNumber()', () => {
+  test.each([...Array(10)])('forceLength = true', () => {
+    const num = fakeNumber(4, true);
+
+    expect(num).toHaveLength(4);
+    expect(typeof num).toBe('string');
+    expect(num).toMatch(/^[\d]+$/);
+  });
+
+  test.each([...Array(10)])('forceLength = false', () => {
+    const num = fakeNumber(4);
+
+    expect(+num).toBeLessThanOrEqual(9999);
+    expect(+num).toBeGreaterThanOrEqual(0);
+    expect(typeof num).toBe('string');
+  });
+
+
+  test.each([...Array(10)])('isAlpha = true', () => {
+    const num = fakeNumber(4, true, true);
+
+    expect(num).toHaveLength(4);
+    expect(typeof num).toBe('string');
+    expect(num).toMatch(/^[0-9A-Z]+$/);
+  });
+});