validation-br 1.5.2 → 2.0.0-next-1

package/test/cnpj.spec.ts

@@ -0,0 +1,127 @@
+import { CNPJ } from '../src/cnpj';
+import * as _cnpj from '../src/cnpj';
+
+describe('CNPJ', () => {
+  describe('constructor', () => {
+    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',
+      '99360938000180',
+      '23693443000100',
+      '32432147000147',
+      '91951438000100',
+    ])('deve estar definido', (input) => {
+      const cnpj = new CNPJ(input);
+      expect(cnpj).toBeDefined();
+      expect(cnpj.value).toMatch(/^\d{14}$/);
+    });
+
+    test.each([
+      // Com máscara
+      '11.222.333/0001-82', // dv invlido
+      '73.797.980/0001-72', // dv invlido
+      '06.946.762/0001-62', // dv invlido
+      '96.051.576/0001-52', // dv invlido
+      '55.585.709/0001-92', // dv invlido
+      '993609380001804', // numero a mais
+      '2369344300010', //   numero a menos
+      '', //                vazio
+      undefined, //         undefined
+      null, //              null
+    ])('deve lançar um erro', (input) => {
+      expect(() => new CNPJ(input as any)).toThrow();
+    });
+  });
+
+  describe('checksum', () => {
+    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 = CNPJ.checksum(item.num);
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+    
+    test.each(['11222333000', '1122233300011', ''])(
+      'deve lançar erro de dv',
+      (item) => {
+        expect(() => CNPJ.checksum(item)).toThrow();
+      }
+    );
+  });
+
+  describe('mask', () => {
+    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: '00432147000150', expected: '00.432.147/0001-50' },
+    ])('máscara correta em %s', (item) => {
+      const masked = new CNPJ(item.value).mask();
+      expect(masked).toBe(item.expected);
+      expect(masked).toHaveLength(18);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fakes devem estar definidos', () => {
+      const cnpj = CNPJ.fake();
+      expect(cnpj).toBeDefined();
+      expect(cnpj).toBeInstanceOf(CNPJ);
+    });
+
+    test.each([...Array(5)])(
+      'fakes alfanuméricos devem estar definidos',
+      () => {
+        const cnpj = CNPJ.fake({ alphanumeric: true });
+        expect(cnpj).toBeDefined();
+        expect(cnpj).toBeInstanceOf(CNPJ);
+      }
+    );
+  });
+
+  describe('CNPJ alfanumérico', () => {
+    test.each(['A3.170.7X3/0001-36', 'A31707X3000136'])(
+      'isValid() - checa se o cnpj alfanumérico %s é válido',
+      (cnpj) => {
+        expect(new CNPJ(cnpj)).toBeDefined()
+      }
+    );
+
+    test.each([
+      { num: 'A12223330001', expected: '50' },
+      { num: 'B12223330001', expected: '03' },
+      { num: 'C12223330001', expected: '67' },
+      { num: 'D12223330001', expected: '10' },
+      { num: 'E12223330001', expected: '74' },
+    ])('Deve gerar um DV correto a partir de %s ', (item) => {
+      const calcDv = CNPJ.checksum(item.num);
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+
+    test.each(['A1222333000', 'B122233300011', ''])(
+      '%s deve lançar erro de dv',
+      (item) => {
+        expect(() => CNPJ.checksum(item)).toThrow();
+      }
+    );
+
+  });
+});

package/test/cpf.spec.ts

@@ -0,0 +1,76 @@
+import { CPF } from '../src/cpf';
+
+describe('CPF', () => {
+  describe('constructor', () => {
+    test.each([
+      '133.782.710-00',
+      '400.448.260-79',
+      '08796742020',
+      '74172316085',
+      '15886489070',
+      '90889477086',
+    ])('deve estar definido', (input) => {
+      expect(new CPF(input)).toBeDefined();
+    });
+
+    test.each([
+      '287.967.420-20',
+      '333.782.710-00',
+      '200.448.260-79',
+      '24172316085',
+      '25886489070',
+      '20889477086',
+      '11111111111', // repetido
+      '', // vazio
+      '012345678900', // caracteres a mais
+      '12345678', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new CPF(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '74172316085', expected: '741.723.160-85' },
+      { num: '15886489070', expected: '158.864.890-70' },
+      { num: '90889477086', expected: '908.894.770-86' },
+      { num: '00889477000', expected: '008.894.770-00' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {    
+      const masked = new CPF(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toHaveLength(14);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const cpf = CPF.fake();
+      expect(cpf).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    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 = CPF.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    
+    test.each(['74172316', '1588648900', ''])(
+      '%s deve lançar erro de dv',
+      (item) => {
+        expect(() => CPF.checksum(item)).toThrow();
+      }
+    );
+
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,112 @@
+import {
+  isCarPlate,
+  isCNH,
+  isCNPJ,
+  isCPF,
+  isJudicialProcess,
+  isNUP17,
+  isPhone,
+  isPIS,
+  isPixCopyPaste,
+  isPixKey,
+  isPostalTrackCode,
+  isRenavam,
+  isTituloEleitor,
+} from '../src/main'
+
+describe('ValidateBR', () => {
+  test('Deve importar isCNH', () => {
+    expect(isCNH).toBeDefined()
+
+    expect(isCNH('69044271146')).toBeTruthy()
+    expect(isCNH('69044271146')).toBeTruthy()
+  })
+
+  test('Deve importar isCNPJ', () => {
+    expect(isCNPJ).toBeDefined()
+
+    expect(isCNPJ('32432147000147')).toBeTruthy()
+    expect(isCNPJ('32432147000147')).toBeTruthy()
+  })
+
+  test('Deve importar isCPF', () => {
+    expect(isCPF).toBeDefined()
+
+    expect(isCPF('15886489070')).toBeTruthy()
+    expect(isCPF('15886489070')).toBeTruthy()
+  })
+
+  test('Deve importar isJudicialProcess', () => {
+    expect(isJudicialProcess).toBeDefined()
+
+    expect(isJudicialProcess('08002732820164058400')).toBeTruthy()
+    expect(isJudicialProcess('08002732820164058400')).toBeTruthy()
+  })
+
+  test('Deve importar isNUP17', () => {
+    expect(isNUP17).toBeDefined()
+
+    expect(isNUP17('23037001462202165')).toBeTruthy()
+    expect(isNUP17('23037001462202165')).toBeTruthy()
+  })
+
+  test('Deve importar isPIS', () => {
+    expect(isPIS).toBeDefined()
+
+    expect(isPIS('23795126955')).toBeTruthy()
+    expect(isPIS('23795126955')).toBeTruthy()
+  })
+
+  test('Deve importar isPostalTrackCode', () => {
+    expect(isPostalTrackCode).toBeDefined()
+
+    expect(isPostalTrackCode('PN718252423BR')).toBeTruthy()
+    expect(isPostalTrackCode('PN718252423BR')).toBeTruthy()
+  })
+
+  test('Deve importar isRenavam', () => {
+    expect(isRenavam).toBeDefined()
+
+    expect(isRenavam('80499688374')).toBeTruthy()
+    expect(isRenavam('80499688374')).toBeTruthy()
+  })
+
+  test('Deve importar isTituloEleitor', () => {
+    expect(isTituloEleitor).toBeDefined()
+
+    expect(isTituloEleitor('153036161686')).toBeTruthy()
+    expect(isTituloEleitor('153036161686')).toBeTruthy()
+  })
+
+  test('Deve importar isCarPlate', () => {
+    expect(isCarPlate).toBeDefined()
+
+    expect(isCarPlate('AAA-1A34')).toBeTruthy()
+    expect(isCarPlate('AAA-1A34')).toBeTruthy()
+  })
+
+  test('Deve importar isPhone', () => {
+    expect(isPhone).toBeDefined()
+
+    expect(isPhone('+5584987654321')).toBeTruthy()
+    expect(isPhone('+558433311454')).toBeTruthy()
+  })
+  test('Deve importar isPixKey', () => {
+    expect(isPixKey).toBeDefined()
+
+    expect(isPixKey('klawdyo@gmail.com')).toBeTruthy()
+    expect(isPixKey('+5584987654321')).toBeTruthy()
+    expect(isPixKey('+558433311454')).toBeTruthy()
+    expect(isPixKey('01234567-0123-4567-8900-000000000000')).toBeTruthy()
+    expect(isPixKey('99360938000180')).toBeTruthy()
+    expect(isPixKey('74172316085')).toBeTruthy()
+  })
+  test('Deve importar isPixCopyPaste', () => {
+    expect(isPixCopyPaste).toBeDefined()
+    const pixStone = `00020101021226820014br.gov.bcb.pix2560pix.stone.com.br/pix/v2/b411f5c8-e97f-4a18-af0e-fc66491748d7520400005303986540510.005802BR5925DIOGO DA SILVA SANTOS LTD6014RIO DE JANEIRO622905251e3afd7926983f8ffe086cdc16304FF60`;
+    const pixManual = `00020126550014BR.GOV.BCB.PIX0123alexandrepato@gmail.com0206almoco5204000053039865406100.005802BR5914Alexandre Pato6009Ipanguacu61085950800062490511PIXJS76657250300017BR.GOV.BCB.BRCODE01051.0.0630455CF`;
+    
+    expect(isPixCopyPaste(pixStone)).toBeTruthy()
+    expect(isPixCopyPaste(pixManual)).toBeTruthy()
+  })
+})

package/test/judicial-process.spec.ts

@@ -0,0 +1,131 @@
+import { JudicialProcess } from '../src/judicial-process';
+
+describe('JudicialProcess', () => {
+  describe('constructor', () => {
+    test.each([
+      '6105283-83.2009.8.13.0024',
+      '00110060720168200100',
+      '08002785520134058400',
+      '08002732820164058400',
+    ])('deve estar definido', (input) => {
+      // console.log(new JudicialProcess(input));
+
+      expect(new JudicialProcess(input)).toBeDefined();
+    });
+
+    test.each([
+      '0110060720168200100',
+      '61052838320098130023',
+      '00110060720168200102',
+      '08002785520134058401',
+      '08002732820164058406',
+      '08002732820160058400', // Órgão judiciário igual a 0
+      '', // vazio
+      '008002732820160058400', // caracteres a mais
+      '8002732820160058400', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro %s', (input) => {
+      expect(() => new JudicialProcess(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '00020802520125150049', 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 = new JudicialProcess(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{7}-\d{2}.\d{4}.\d.\d{2}.\d{4}$/);
+    });
+  });
+
+  describe('fake()', () => {
+    test.each([...Array(5)])('Deve gerar um fake válido', () => {
+      const result = JudicialProcess.fake();
+      expect(result).toBeDefined();
+    });
+
+    test.each([...Array(5)])(
+      'Deve gerar um fake válido com o órgão definido',
+      () => {
+        const result = JudicialProcess.fake({ court: '3' });
+        expect(result).toBeDefined();
+        expect(result.court).toBe('3');
+      }
+    );
+
+    test.each([...Array(5)])(
+      'Deve gerar um fake válido com o tribunal definido',
+      () => {
+        const result = JudicialProcess.fake({ subCourt: '13' });
+        expect(result).toBeDefined();
+        expect(result.subCourt).toBe('13');
+      }
+    );
+
+    test.each([...Array(5)])(
+      'Deve gerar um fake válido com o ano definido',
+      () => {
+        const result = JudicialProcess.fake({ year: '2024' });
+        expect(result).toBeDefined();
+        expect(result.year).toBe('2024');
+      }
+    );
+
+    test.each([...Array(5)])(
+      'Deve gerar um fake válido com a unidade de origem definida',
+      () => {
+        const result = JudicialProcess.fake({ origin: '1313' });
+        expect(result).toBeDefined();
+        expect(result.origin).toBe('1313');
+      }
+    );
+
+    test.each([
+      { court: '0' },
+      { court: '11' },
+      { subCourt: '1' },
+      { subCourt: '00' },
+      { subCourt: '111' },
+      { year: '111' },
+      { year: '11111' },
+      { origin: '0000' },
+      { origin: '111' },
+      { origin: '11111' },
+    ])(
+      'Deve lançar erro quando tenta criar fake com valores pré-definidos inválidos %s',
+      (input) => {
+        expect(() => JudicialProcess.fake(input)).toThrow();
+      }
+    );
+  });
+
+  describe('checksum', () => {
+    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 = JudicialProcess.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+        
+    test.each(['0002080201251500499', '00020802012515004', ''])(
+      'deve lançar erro de dv',
+      (item) => {
+        expect(() => JudicialProcess.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/nup17.spec.ts

@@ -0,0 +1,79 @@
+import { NUP17 } from '../src/nup17';
+
+describe('NUP17', () => {
+  describe('constructor', () => {
+    test.each([
+      // Masked
+      '23037.001380/2021-11',
+      '23037.001434/2021-48',
+      '23037.001321/2021-42',
+      // String
+      '23037001462202165',
+      '23037001537202116',
+      '23037001086202117',
+    ])('%s deve ser definido', (input) => {
+      expect(new NUP17(input)).toBeDefined();
+    });
+
+    test.each([
+      '23037001380202112',
+      '23037001434202142',
+      '23037001462202162',
+      '23037001537202112',
+      '', // vazio
+      '023037001537202112', // caracteres a mais
+      '3037001537202112', // caracteres a menos
+      null,
+      undefined,
+    ])('%s deve lançar erro', (input) => {
+      expect(() => new NUP17(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '23037001380202111', expected: '23037.001380/2021-11' },
+      { num: '23037001434202148', expected: '23037.001434/2021-48' },
+      { num: '23037001321202142', expected: '23037.001321/2021-42' },
+      { num: '23037001462202165', expected: '23037.001462/2021-65' },
+      { num: '23037001537202116', expected: '23037.001537/2021-16' },
+      { num: '23037001086202117', expected: '23037.001086/2021-17' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+      const masked = new NUP17(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{5}\.\d{6}\/\d{4}-\d{2}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('Deve gerar fake válido', () => {
+      const result = NUP17.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '230370013802021', expected: '11' },
+      { num: '230370014342021', expected: '48' },
+      { num: '230370013212021', 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 = NUP17.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+        
+    test.each(['23037001462202', '2303700146220211', ''])(
+      'deve lançar erro de dv',
+      (item) => {
+        expect(() => NUP17.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/phone.spec.ts

@@ -0,0 +1,75 @@
+import { Phone } from '../src/phone';
+
+const cellPhones = ['+5584999580685', '+55 84 9 9958 0685', '+55 (84) 9 9958-0685', '+55 (84) 99958-0685', '84 99958-0685'];
+const phones = ['+558433311454', '84 3331-1454', '84 3331 1454', '(84) 3331 1454', '84-3331-1454'];
+
+describe('Phone', () => {
+  describe('constructor', () => {
+    test.each(cellPhones)('Celular %s deve estar definido', (value) => {
+      const obj = new Phone(value);
+      expect(obj.value).toBe('+5584999580685');
+      expect(obj.ddi).toBe('+55');
+      expect(obj.ddd).toBe('84');
+      expect(obj.phone).toBe('999580685');
+      expect(obj.isMobile).toBeTruthy();
+    });
+
+    test.each(phones)('Telefone fixo %s deve estar definido', (value) => {
+      const obj = new Phone(value);
+      expect(obj.value).toBe('+558433311454');
+      expect(obj.ddi).toBe('+55');
+      expect(obj.ddd).toBe('84');
+      expect(obj.phone).toBe('33311454');
+      expect(obj.isMobile).toBeFalsy;
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('Cria um fake', () => {
+      const fake = Phone.fake();
+      expect(fake).toBeDefined();
+    });
+
+    test.each([...Array(5)])('Cria um fake com DDD 11', () => {
+      const fake = Phone.fake({ ddd: '11' });
+      expect(fake).toBeDefined();
+      expect(fake.ddd).toBe('11');
+    });
+
+    test.each([...Array(5)])('Cria um fake com isMobile=true', () => {
+      const fake = Phone.fake({ isMobile: true });
+      expect(fake).toBeDefined();
+      expect(fake.isMobile).toBeTruthy()
+      expect(fake.phone.length).toBe(9)
+    });
+
+    test.each([...Array(5)])('Cria um fake com isLandline=true', () => {
+      const fake = Phone.fake({ isLandline: true });      
+      expect(fake).toBeDefined();
+      expect(fake.isMobile).toBeFalsy()
+      expect(fake.phone.length).toBe(8)
+    });
+  });
+
+  describe('mask', () => {
+    test.each(cellPhones)('Máscara de celular sem país', (input) => {
+      const phone = new Phone(input);
+      expect(phone.mask({ withCountry: false })).toBe('84 999580685');
+    });
+
+    test.each(cellPhones)('Máscara de celular com país', (input) => {
+      const phone = new Phone(input);
+      expect(phone.mask({ withCountry: true })).toBe('+55 84 999580685');
+    });
+
+    test.each(phones)('Máscara de telefone fixo sem país', (input) => {
+      const phone = new Phone(input);
+      expect(phone.mask({ withCountry: false })).toBe('84 33311454');
+    });
+
+    test.each(phones)('Máscara de telefone fixo com país', (input) => {
+      const phone = new Phone(input);
+      expect(phone.mask({ withCountry: true })).toBe('+55 84 33311454');
+    });
+  });
+});

package/test/pis-pasep.spec.ts

@@ -0,0 +1,73 @@
+import { PIS } from '../src/pis-pasep';
+
+describe('PIS', () => {
+  describe('constructor', () => {
+    test.each([
+      '71282677380',
+      '23795126955',
+      '50012973803',
+      '27890141144',
+      '268.27649.96-0',
+      '613.01862.91-7',
+    ])('deve estar definido', (input) => {
+      expect(new PIS(input)).toBeDefined();
+    });
+
+    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',
+      '', // vazio
+      '0613.01862.91-4', // caracteres a mais
+      '13.01862.91-4', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new PIS(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '71282677380', expected: '712.82677.38-0' },
+      { num: '23795126955', expected: '237.95126.95-5' },
+      { num: '50012973803', expected: '500.12973.80-3' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+      const masked = new PIS(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{3}.\d{5}.\d{2}-\d{1}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('deve gerar um fake válido', () => {
+      const result = PIS.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '7128267738', expected: '0' },
+      { num: '2379512695', expected: '5' },
+      { num: '5001297380', expected: '3' },
+    ])('%s deve gerar dv correto', (item) => {
+      const calcDv = PIS.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    test.each(['712826778', '71282677381', ''])(
+      '%s deve lançar erro de dv',
+      (item) => {
+        expect(() => PIS.checksum(item)).toThrow();
+      }
+    );
+  });
+});