validation-br 1.5.2 → 1.6.0

package/test/cnh.test.ts

@@ -0,0 +1,113 @@
+import isCNH, { dv, fake, mask, normalize, validate, validateOrFail } from '../src/cnh';
+import * as _cnh from '../src/cnh';
+
+describe('CNH', () => {
+  test.each([
+    // como inteiro
+    50195131143,
+    58316794534,
+    50195471165,
+    // como string
+    '69044271146',
+    '46190906839',
+    // com máscara
+    '624729276-37',
+  ])('isCNH() - Números válidos', (item) => {
+
+    expect(isCNH(item)).toBeTruthy();
+    expect(_cnh.validate(item)).toBeTruthy();
+
+
+  });
+
+  test.each([
+    // como inteiro
+    50195131143,
+    58316794534,
+    // como string
+    '69044271146',
+    '46190906839',
+    // com máscara
+    '624729276-37',
+  ])('validate() - Números válidos', (item) => {
+
+    // t.true(isCNH(cnh), `CNH ${cnh} deve ser válida`)
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    // 
+    '50195471143',
+    '58316474534',
+    '69044471146',
+    '33333333333',
+    '88888888888'
+  ])('validate() - Números inválidos', (item) => {
+
+    expect(validate(item)).toBeFalsy();
+
+  });
+
+  test.each(['50195471143', '58316474534', '69044471146', '33333333333', '88888888888'])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCNH('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cnh = fake();
+    expect(validate(cnh)).toBeTruthy();
+    expect(cnh).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cnh = fake(true);
+    expect(validate(cnh)).toBeTruthy();
+    expect(cnh).toHaveLength(12);
+
+  });
+
+  test.each([
+    { value: '501954711', expected: '65' },
+    { value: 583164745, expected: '75' },
+    { value: 690444711, expected: '17' },
+  ])('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: 50195471143, expected: '501954711-43' },
+    { value: 58316474534, expected: '583164745-34' },
+    { value: 69044471146, expected: '690444711-46' },
+  ])('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: '501954711-43', expected: '50195471143' },
+    { value: '583164745-34', expected: '58316474534' },
+    { value: '690444711-46', expected: '69044471146' },
+    { value: '50195471143', expected: '50195471143' },
+    { value: '58316474534', expected: '58316474534' },
+    { value: '69044471146', expected: '69044471146' },
+  ])('normalize() - Testando se remove a máscara corretamente', (item) => {
+
+    const normalized = normalize(item.value);
+
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(11);
+  });
+});

package/test/cnpj.test.ts

@@ -0,0 +1,179 @@
+import isCNPJ, { dv, fake, mask, validate, validateOrFail, normalize } from '../src/cnpj';
+import * as _cnpj from '../src/cnpj';
+
+describe('CNPJ', () => {
+  test.each([
+    // Com máscara
+    '11.222.333/0001-81',
+    '73.797.980/0001-79',
+    '06.946.762/0001-61',
+    '96.051.576/0001-57',
+    '55.585.709/0001-98',
+    // inteiro
+    99360938000180,
+    23693443000100,
+    // string
+    '32432147000147',
+    '91951438000100',
+  ])('isCNPJ() - Números válidos', (cnpj) => {
+    expect(isCNPJ(cnpj)).toBeTruthy();
+    expect(_cnpj.validate(cnpj)).toBeTruthy();
+  });
+
+  test.each([
+    // Com máscara
+    '11.222.333/0001-81',
+    '73.797.980/0001-79',
+    '06.946.762/0001-61',
+    '96.051.576/0001-57',
+    '55.585.709/0001-98',
+    // inteiro
+    99360938000180,
+    23693443000100,
+    // string
+    '32432147000147',
+    '91951438000100',
+  ])('validate() - Números válidos', (cnpj) => {
+
+    expect(validate(cnpj)).toBeTruthy();
+  });
+
+  test.each([
+    '53.797.980/0001-79',
+    '36.946.762/0001-61',
+    '26.051.576/0001-57',
+    '85.585.709/0001-98',
+    '39360938000180',
+    '93693443000100',
+    '12432147000147',
+    '61951438000100',
+    '11111111111111',
+  ])('validate() - Números inválidos', (cnpj) => {
+    expect(validate(cnpj)).toBeFalsy();
+  });
+
+  test.each([
+    '53.797.980/0001-79',
+    '36.946.762/0001-61',
+    '26.051.576/0001-57',
+    '85.585.709/0001-98',
+    '39360938000180',
+    '93693443000100',
+    '12432147000147',
+    '61951438000100',
+    '11111111111111',
+  ])('validateOrFail() - Números inválidos', (cnpj) => {
+    expect(() => validateOrFail(cnpj)).toThrow();
+
+
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCNPJ('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cnpj = fake();
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cnpj = fake(true);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(18);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara usando opções como objeto', () => {
+    const cnpj = fake({ withMask: true, alphanumeric: false });
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(18);
+    expect(cnpj).toMatch(/^\d{2}\.\d{3}\.\d{3}\/\d{4}\-\d{2}$/);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara usando opções como objeto', () => {
+    const cnpj = fake({ withMask: false, alphanumeric: false });
+    expect(cnpj).toMatch(/^\d{14}$/);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([...Array(5)])('fake() - Gera CNPJs alfanuméricos', () => {
+    const cnpj = fake({ withMask: false, alphanumeric: true });
+    expect(cnpj).toMatch(/^[0-9A-Z]{14}$/);
+    expect(validate(cnpj)).toBeTruthy();
+    expect(cnpj).toHaveLength(14);
+  });
+
+  test.each([
+    { num: '112223330001', expected: '81' },
+    { num: 993609380001, expected: '80' },
+    { num: '324321470001', expected: '47' },
+    { num: '132496630001', expected: '96' },
+    { num: '752827070001', expected: '37' },
+    { num: '265066480001', expected: '28' },
+    { num: '708032680001', expected: '47' },
+    { num: '195255840001', expected: '47' },
+    { num: '888634370001', expected: '08' },
+    { num: '060757490001', expected: '84' },
+    { num: '554120850001', expected: '07' },
+    { num: '754097240001', expected: '92' },
+
+  ])('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: '11222333000181', expected: '11.222.333/0001-81' },
+    { value: 99360938000180, expected: '99.360.938/0001-80' },
+    { value: '32432147000147', expected: '32.432.147/0001-47' },
+    { value: 432147000147, expected: '00.432.147/0001-47' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.value);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(18);
+  });
+
+  test.each([
+    { value: '11.222.333/0001-81', expected: '11222333000181' },
+    { value: '73.797.980/0001-79', expected: '73797980000179' },
+    { value: '06.946.762/0001-61', expected: '06946762000161' },
+    { value: '96.051.576/0001-57', expected: '96051576000157' },
+    { value: '55.585.709/0001-98', expected: '55585709000198' },
+  ])('normalize() - Deve remover a máscara corretamente', (item) => {
+    const normalized = normalize(item.value);
+    expect(normalized).toBe(item.expected);
+    expect(normalized).toHaveLength(14);
+  });
+
+});
+
+describe('CNPJ alfanumérico', () => {
+
+  test.each([
+    'A3.170.7X3/0001-36',
+    'A31707X3000136',
+  ])('isValid() - checa se o cnpj alfanumérico %s é válido', (cnpj) => {
+    expect(validate(cnpj)).toBeTruthy();
+  });
+
+
+  test.each([
+    { num: 'A1.222.333/0001', expected: '50' },
+    { num: 'B1.222.333/0001', expected: '03' },
+    { num: 'C1.222.333/0001', expected: '67' },
+    { num: 'D12223330001', expected: '10' },
+    { num: 'E12223330001', expected: '74' },
+  ])('dv() - Verificando se o DV gerado de %s está correto', (item) => {
+    const calcDv = dv(item.num);
+    expect(calcDv).toBe(item.expected);
+    expect(typeof calcDv).toBe('string');
+  });
+
+
+});

package/test/cpf.test.ts

@@ -0,0 +1,124 @@
+import isCPF, { dv, fake, mask, validate, validateOrFail, normalize } from '../src/cpf';
+import * as _cpf from '../src/cpf';
+
+describe('CPF', () => {
+  test.each([
+    // masked
+    '133.782.710-00',
+    '400.448.260-79',
+    // integer
+    8796742020, // começa com zero
+    74172316085,
+    // string
+    '15886489070',
+    '90889477086',
+  ])('isCPF() - Números válidos', (item) => {
+
+    expect(isCPF(item)).toBeTruthy();
+    expect(_cpf.validate(item)).toBeTruthy();
+
+  });
+
+  test.each([
+    // masked
+    '133.782.710-00',
+    '400.448.260-79',
+    // integer
+    8796742020, // começa com zero
+    74172316085,
+    // string
+    '15886489070',
+    '90889477086',
+  ])('validate() - Números válidos', (item) => {
+    expect(validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    '287.967.420-20',
+    '333.782.710-00',
+    '200.448.260-79',
+    '24172316085',
+    '25886489070',
+    '20889477086',
+    '11111111111',
+  ])('validate() - Números inválidos', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test.each([
+    '287.967.420-20',
+    '333.782.710-00',
+    '200.448.260-79',
+    '24172316085',
+    '25886489070',
+    '20889477086',
+    '11111111111',
+  ])('validateOrFail() - Números inválidos', (item) => {
+    expect(() => validateOrFail(item)).toThrow();
+  });
+
+  test.each([
+    '24172316085000000',
+    '25886489070999999',
+    '20889477086888888',
+    '11111111111777777',
+  ])('validate() - Números válidos com caracteres adicionais', (item) => {
+    expect(validate(item)).toBeFalsy();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isCPF('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+    const cpf = fake();
+    expect(validate(cpf)).toBeTruthy();
+    expect(cpf).toHaveLength(11);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const cpf = fake(true);
+    expect(validate(cpf)).toBeTruthy();
+    expect(cpf).toHaveLength(14);
+  });
+
+  test.each([
+    { num: '741723160', expected: '85' },
+    { num: 158864890, expected: '70' },
+    { num: '908894770', expected: '86' },
+  ])('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([
+    { num: '74172316085', expected: '741.723.160-85' },
+    { num: 15886489070, expected: '158.864.890-70' },
+    { num: '90889477086', expected: '908.894.770-86' },
+    { num: 889477086, expected: '008.894.770-86' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.num);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(14);
+  });
+
+  test.each([
+    { value: '741.723.160-85', expected: '74172316085' },
+    { value: '158.864.890-70', expected: '15886489070' },
+    { value: '908.894.770-86', expected: '90889477086' },
+    { value: '008.894.770-86', expected: '00889477086' },
+    { value: '74172316085', expected: '74172316085' },
+    { value: '15886489070', expected: '15886489070' },
+    { value: '90889477086', expected: '90889477086' },
+    { value: '889477086', expected: '00889477086' },
+  ])('normalize() - Testando se remove a máscara corretamente', (item) => {
+    const masked = normalize(item.value);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(11);
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,85 @@
+import ValidateBR, {
+  isCNH,
+  isCNPJ,
+  isCPF,
+  isJudicialProcess,
+  isNUP17,
+  isPIS,
+  isPostalCode,
+  isRenavam,
+  isTituloEleitor,
+} from '../src/index';
+
+describe('ValidateBR', () => {
+  test('Deve importar isCNH', () => {
+    expect(ValidateBR.isCNH).toBeDefined();
+    expect(isCNH).toBeDefined();
+
+    expect(ValidateBR.isCNH('69044271146')).toBeTruthy();
+    expect(isCNH('69044271146')).toBeTruthy();
+  });
+
+  test('Deve importar isCNPJ', () => {
+    expect(ValidateBR.isCNPJ).toBeDefined();
+    expect(isCNPJ).toBeDefined();
+
+    expect(ValidateBR.isCNPJ('32432147000147')).toBeTruthy();
+    expect(isCNPJ('32432147000147')).toBeTruthy();
+  });
+
+  test('Deve importar isCPF', () => {
+    expect(ValidateBR.isCPF).toBeDefined();
+    expect(isCPF).toBeDefined();
+
+    expect(ValidateBR.isCPF('15886489070')).toBeTruthy();
+    expect(isCPF('15886489070')).toBeTruthy();
+  });
+
+  test('Deve importar isJudicialProcess', () => {
+    expect(ValidateBR.isJudicialProcess).toBeDefined();
+    expect(isJudicialProcess).toBeDefined();
+
+    expect(ValidateBR.isJudicialProcess('08002732820164058400')).toBeTruthy();
+    expect(isJudicialProcess('08002732820164058400')).toBeTruthy();
+  });
+
+  test('Deve importar isNUP17', () => {
+    expect(ValidateBR.isNUP17).toBeDefined();
+    expect(isNUP17).toBeDefined();
+
+    expect(ValidateBR.isNUP17('23037001462202165')).toBeTruthy();
+    expect(isNUP17('23037001462202165')).toBeTruthy();
+  });
+
+  test('Deve importar isPIS', () => {
+    expect(ValidateBR.isPIS).toBeDefined();
+    expect(isPIS).toBeDefined();
+
+    expect(ValidateBR.isPIS('23795126955')).toBeTruthy();
+    expect(isPIS('23795126955')).toBeTruthy();
+  });
+
+  test('Deve importar isPostalCode', () => {
+    expect(ValidateBR.isPostalCode).toBeDefined();
+    expect(isPostalCode).toBeDefined();
+
+    expect(ValidateBR.isPostalCode('PN718252423BR')).toBeTruthy();
+    expect(isPostalCode('PN718252423BR')).toBeTruthy();
+  });
+
+  test('Deve importar isRenavam', () => {
+    expect(ValidateBR.isRenavam).toBeDefined();
+    expect(isRenavam).toBeDefined();
+
+    expect(ValidateBR.isRenavam('80499688374')).toBeTruthy();
+    expect(isRenavam('80499688374')).toBeTruthy();
+  });
+
+  test('Deve importar isTituloEleitor', () => {
+    expect(ValidateBR.isTituloEleitor).toBeDefined();
+    expect(isTituloEleitor).toBeDefined();
+
+    expect(ValidateBR.isTituloEleitor('153036161686')).toBeTruthy();
+    expect(isTituloEleitor('153036161686')).toBeTruthy();
+  });
+});

package/test/judicialProcess.test.ts

@@ -0,0 +1,120 @@
+import isJudicialProcess, {
+  dv,
+  fake,
+  mask,
+  validate,
+  validateOrFail,
+  _getSubCourt,
+  normalize,
+} from '../src/judicialProcess';
+
+import * as _judicialProcess from '../src/judicialProcess';
+
+describe('JudicialProcess', () => {
+  test.each([
+    '20802520125150049',
+    '61052838320098130024',
+    '00110060720168200100',
+    '08002785520134058400',
+    '08002732820164058400',
+  ])('isJudicialProcess() - Números válidos', (item) => {
+    expect(isJudicialProcess(item)).toBeTruthy();
+    expect(_judicialProcess.validate(item)).toBeTruthy();
+  });
+
+  test.each([
+    '20802520125150044',
+    '61052838320098130023',
+    '00110060720168200102',
+    '08002785520134058401',
+    '08002732820164058406',
+    '08002732820160058400', // Órgão judiciário igual a 0
+  ])('Números inválidos', (judicialProcess) => {
+    expect(validate(judicialProcess)).toBeFalsy();
+    expect(() => validateOrFail(judicialProcess)).toThrow();
+  });
+
+  test('Parâmetro não informado', () => {
+    expect(isJudicialProcess('')).toBeFalsy();
+    expect(validate('')).toBeFalsy();
+    expect(() => validateOrFail('')).toThrow();
+    expect(() => dv('')).toThrow();
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const judicialProcess = fake();
+      expect(validate(judicialProcess)).toBeTruthy();
+      expect(judicialProcess).toHaveLength(20);
+  });
+
+  test.each([...Array(5)])('fake() - Gera fakes com máscara', () => {
+    const judicialProcess = fake(true);
+    expect(validate(judicialProcess)).toBeTruthy();
+    expect(judicialProcess).toHaveLength(25);
+  });
+
+  test.each([
+    { num: '000208020125150049', expected: '25' },
+    { num: '610528320098130024', expected: '83' },
+    { num: '001100620168200100', expected: '07' },
+    { num: '080027820134058400', expected: '55' },
+    { num: '080027320164058400', expected: '28' },
+  ])('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([
+    { num: '20802520125150049', expected: '0002080-25.2012.5.15.0049' },
+    { num: '61052838320098130024', expected: '6105283-83.2009.8.13.0024' },
+    { num: '00110060720168200100', expected: '0011006-07.2016.8.20.0100' },
+    { num: '08002785520134058400', expected: '0800278-55.2013.4.05.8400' },
+    { num: '08002732820164058400', expected: '0800273-28.2016.4.05.8400' },
+  ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+    const masked = mask(item.num);
+
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(25);
+  });
+
+  test.each([
+    { value: '0002080-25.2012.5.15.0049', expected: '00020802520125150049' },
+    { value: '6105283-83.2009.8.13.0024', expected: '61052838320098130024' },
+    { value: '0011006-07.2016.8.20.0100', expected: '00110060720168200100' },
+    { value: '0800278-55.2013.4.05.8400', expected: '08002785520134058400' },
+    { value: '0800273-28.2016.4.05.8400', expected: '08002732820164058400' },
+    // Already normalized values
+    { value: '20802520125150049', expected: '00020802520125150049' },
+    { value: '61052838320098130024', expected: '61052838320098130024' },
+    { value: '110060720168200100', expected: '00110060720168200100' },
+    { value: '8002785520134058400', expected: '08002785520134058400' },
+    { value: '8002732820164058400', expected: '08002732820164058400' },
+  ])('normalize() - Testando se remove a máscara corretamente', (item) => {
+    const masked = normalize(item.value);
+    expect(masked).toBe(item.expected);
+    expect(masked).toHaveLength(20);
+  });
+
+  test('_getSubCourt() - Valor diferente de zero', () => {
+    expect(_getSubCourt('01')).toBe('01');
+    expect(_getSubCourt('02')).toBe('02');
+    expect(_getSubCourt('03')).toBe('03');
+    expect(_getSubCourt('04')).toBe('04');
+    expect(_getSubCourt('05')).toBe('05');
+    expect(_getSubCourt('06')).toBe('06');
+    expect(_getSubCourt('07')).toBe('07');
+    expect(_getSubCourt('08')).toBe('08');
+    expect(_getSubCourt('09')).toBe('09');
+  });
+
+  test('_getSubCourt() - Valor igual a zero', () => {
+    expect(_getSubCourt('00')).toBe('01');
+    expect(_getSubCourt('0')).toBe('01');
+  });
+
+  test('_getSubCourt() - Valor vazio', () => {
+    expect(_getSubCourt().length).toBe(2);
+  });
+});