validation-br 1.6.0 → 1.6.1

package/test/nup17.test.ts

@@ -1,127 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,69 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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]+$/);
-  });
-});