validation-br 1.5.1 → 2.0.0-next-1

package/test/pix-copy-paste.spec.ts

@@ -0,0 +1,37 @@
+// pix usado pelo 10 pila.
+
+import { PixCopyPaste } from '../src/pix-copy-paste';
+
+// esse pix é um pix automatico
+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`;
+
+const cases = [
+  pixStone, 
+  pixManual
+]
+
+
+describe('PixCopyPaste', () => {
+  describe('constructor', () => {
+    test.each(cases)('deve estar definido', (input) => {
+      const pix = new PixCopyPaste(input);
+      expect(pix).toBeDefined();
+    });
+    
+    test('deve lançar um erro ao injetar um caractere na terceira posição', () => {
+      const copyPaste = pixStone.slice(0, 4) + 'D' + pixStone.slice(4);
+      expect(()=>new PixCopyPaste(copyPaste)).toThrow()
+    });
+  });
+
+  describe('parse', () => {
+    test.each(cases)('testa o parse', (input) => {
+      const parse = PixCopyPaste.parse(input);
+      
+      expect(parse).toBeDefined();
+      expect(Array.isArray(parse)).toBeTruthy();
+    });
+  });
+});
+

package/test/pix-key.spec.ts

@@ -0,0 +1,41 @@
+import { PixKey, PixKeys } from '../src/pix-key';
+
+describe('Pix', () => {
+  describe('constructor', () => {
+    test('deve estar definido do tipo e-mail', () => {
+      const key = new PixKey('klawdyo@gmail.com');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.email);
+    });
+
+    test('deve estar definido do tipo cpf', () => {
+      const key = new PixKey('004.129.620-63');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.cpf);
+    });
+
+    test('deve estar definido do tipo cnpj', () => {
+      const key = new PixKey('41356581000186');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.cnpj);
+    });
+
+    test('deve estar definido do tipo aleatória', () => {
+      const key = new PixKey('01234567-0123-4567-8901-234567890123');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.evp);
+    });
+
+    test('deve estar definido do tipo phone', () => {
+      const key = new PixKey('+5584987654321');
+      expect(key).toBeDefined();
+      expect(key.type).toBe(PixKeys.phone);
+    });
+
+    test('deve falhar ao receber um telefone inválido', () => {
+      expect(() => new PixKey('+55849876')).toThrow()
+    });
+
+
+  });
+});

package/test/postal-track-code.test.ts

@@ -0,0 +1,83 @@
+import { PostalTrackCode } from '../src/postal-track-code';
+
+describe('PostalTrackCode', () => {
+  describe('constructor', () => {
+    test.each([
+      'PN718252423BR',
+      'PO925539762BR',
+      'JT194690698BR',
+      'SV143851674BR',
+      'RG727348650CN',
+      'RY747622885CN',
+      'RY728187035CN',
+      'RH940629235CN',
+      'RY686586175CN',
+      'RY648001205CN',
+      'UJ776469464CN',
+      'LZ667841882CN',
+      'RS737783818NL',
+    ])('%s deve estar definido', (input) => {
+      expect(new PostalTrackCode(input)).toBeDefined();
+    });
+
+    test.each([
+      'PO925524762BR', // dv inválido
+      'JT194624698BR', // dv inválido
+      'SV143824674BR', // dv inválido
+      'RG727324650CN', // dv inválido
+      'RY747624885CN', // dv inválido
+      'RY728114035CN', // dv inválido
+      'RY728114035', // sem letras no final
+      'RY728114035N', // 1 letra no final
+      'RS737783818NLL', // 3 letras no final
+      '737783818NL', // sem letra no começo
+      'S737783818NL', // só 1 letra no começo
+      'ARS737783818NL', // 3 letras no começo
+      'RS73778381NL', // numero a menos
+      null,
+      undefined,
+    ])('%s deve lançar erro', (input) => {
+      expect(() => new PostalTrackCode(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: 'pn718252423br', expected: 'PN718252423BR' },
+      { num: 'po925539762br', expected: 'PO925539762BR' },
+      { num: 'jt194690698br', expected: 'JT194690698BR' },
+    ])('Deve aplicar a máscara corretamente', (item) => {
+      const masked = new PostalTrackCode(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^[A-Z]{2}\d{9}[A-Z]{2}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('deve gerar fakes válidos', () => {
+      const result = PostalTrackCode.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '71825242', expected: '3' },
+      { num: '92553976', expected: '2' },
+      { num: '19469069', expected: '8' },
+    ])('Deve calcular o Dv corretamente', (item) => {
+      const calcDv = PostalTrackCode.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    test.each(['PN718252423BR', '925539762BR', 'JT194690698'])(
+      'Deve lançar erro',
+      (item) => {
+        expect(() => PostalTrackCode.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/renavam.spec.ts

@@ -0,0 +1,71 @@
+import { Renavam } from '../src/renavam';
+
+describe('Renavam', () => {
+  describe('constructor', () => {
+    test.each([
+      '1952519770-3',
+      '3394038959-9',
+      '03607626105',
+      '64090416160',
+      '80499688374',
+      '40650543741',
+    ])('deve estar definido', (input) => {
+      expect(new Renavam(input)).toBeDefined();
+    });
+
+    test.each([
+      '19525227703',
+      '33940229599',
+      '03607226105',
+      '64090226160',
+      '80499228374',
+      '', // vazio
+      '012345678900', // caracteres a mais
+      '12345678', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new Renavam(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '03607626105', expected: '0360762610-5' },
+      { num: '64090416160', expected: '6409041616-0' },
+      { num: '80499688374', expected: '8049968837-4' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
+      const masked = new Renavam(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{10}-\d{1}$/);
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const result = Renavam.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '1952519770', expected: '3' },
+      { num: '0952519770', expected: '6' },
+      { num: '0052519770', expected: '2' },
+    ])('Deve gerar o dv correto', (item) => {
+      const calcDv = Renavam.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+
+    test.each(['00525197701', '0052519770-1', '005251977'])(
+      'deve lançar erro de dv',
+      (item) => {
+        expect(() => Renavam.checksum(item)).toThrow();
+      }
+    );
+  });
+});

package/test/tituloEleitor.spec.ts

@@ -0,0 +1,72 @@
+import { TituloEleitor } from "../src/tituloEleitor";
+
+describe('TituloEleitor', () => {
+  describe('constructor', () => {
+    test.each([
+     // masked
+     '1023.8501.0671',
+     '8365.7137.1619',
+     // string
+     '153036161686',
+     '525028881694',
+     // integer
+     '011122223360',
+     '001122223336',
+    ])('deve estar definido', (input) => {
+      expect(new TituloEleitor(input)).toBeDefined();
+    });
+
+    test.each([
+      '836531371619',
+      '743620641660',
+      '153016161686',
+      '525078881694',
+      '026367681660',
+      '558647441635',
+      '222222222222',
+      '', // vazio
+      '012345678900', // caracteres a mais
+      '12345678', // caracteres a menos
+      null,
+      undefined,
+    ])('deve lançar erro', (input) => {
+      expect(() => new TituloEleitor(input as any)).toThrow();
+    });
+  });
+
+  describe('mask', () => {
+    test.each([
+      { num: '102385010671', expected: '1023.8501.0671' },
+      { num: '836571371619', expected: '8365.7137.1619' },
+      { num: '743650641660', expected: '7436.5064.1660' },
+      { num: '011122223360', expected: '0111.2222.3360' },
+      { num: '001122223336', expected: '0011.2222.3336' },
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {    
+      const masked = new TituloEleitor(item.num).mask();
+
+      expect(masked).toBe(item.expected);
+      expect(masked).toMatch(/^\d{4}.\d{4}.\d{4}$/)
+    });
+  });
+
+  describe('fake', () => {
+    test.each([...Array(5)])('fake() - Gera fakes sem máscara', () => {
+      const result = TituloEleitor.fake();
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe('checksum', () => {
+    test.each([
+      { num: '1023850106', expected: '71' },
+      { num: '8365713716', expected: '19' },
+      { num: '7436506416', expected: '60' },
+      { num: '0011222233', expected: '36' },
+    ])('dv() - Verificando se o DV gerado está correto', (item) => {
+      const calcDv = TituloEleitor.checksum(item.num);
+
+      expect(calcDv).toBe(item.expected);
+      expect(typeof calcDv).toBe('string');
+    });
+  });
+});

package/test/utils-applyMask.test.ts

@@ -0,0 +1,17 @@
+import { applyMask } from '../src/utils'
+
+describe('applyMask()', () => {
+  const items = [
+    { 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' },
+  ]
+
+  test('Máscara deve ser aplicada com o valor e tamanho correto', () => {
+    items.forEach((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,85 @@
+import { clearValue } from '../src/utils'
+
+describe('clearValue()', () => {
+  test('Deve limpar o valor - Strings do Mesmo tamanho', () => {
+    //
+    const valid = [
+      { value: 1234567890, size: 10, expected: '1234567890' },
+      { value: '1234567890', size: 10, expected: '1234567890' },
+      { value: '12.345.678-90', size: 10, expected: '1234567890' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size)).toBe(item.expected)
+    })
+  })
+
+  test('Deve limpar os caracteres não numéricos sem verificar o tamanho da string', () => {
+    //
+    const valid = [
+      { value: 1234567890123, size: null, expected: '1234567890123' },
+      { value: '4567890', size: null, expected: '4567890' },
+      { value: '345.678-90', size: null, expected: '34567890' },
+    ]
+
+    valid.forEach((item) => {
+      expect(clearValue(item.value, item.size)).toBe(item.expected)
+    })
+  })
+
+  test('Deve limpar o valor os caracteres não numéricos e completar com zeros à esquerda', () => {
+    //
+    const valid = [
+      { value: 1234, size: 10, expected: '0000001234' },
+      { value: '1234', size: 10, expected: '0000001234' },
+      { value: '123-4', size: 10, expected: '0000001234' },
+    ]
+
+    valid.forEach((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('Deve limpar o valor os caracteres não numéricos e remover os caracteres que passarem de size', () => {
+    //
+    const valid = [
+      { value: 123456789, size: 4, expected: '1234' },
+      { value: '1234567890', size: 4, expected: '1234' },
+      { value: '12.345.678-90', size: 4, expected: '1234' },
+    ]
+
+    valid.forEach((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, { rejectIfLonger: true })).toBe('1234')
+    expect(() => clearValue('12345', 4, { rejectIfLonger: 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]+$/)
+  })
+})

package/test/utils-insertAtPosition.test.ts

@@ -0,0 +1,15 @@
+import { insertAtPosition } from '../src/utils'
+
+describe('insertAtPosition()', () => {
+  test('Deve inserir um caractere em uma determinada posição da string', () => {
+    //
+    const list = [
+      { value: 'AAABBB', insert: 'C', position: 3, expected: 'AAACBBB' },
+      { value: 'J Med', insert: 'Cl ', position: 2, expected: 'J Cl Med' },
+    ]
+
+    list.forEach((item) => {
+      expect(insertAtPosition(item.value, item.insert, item.position)).toBe(item.expected)
+    })
+  })
+})

package/test/utils-randomLetter.test.ts

@@ -0,0 +1,14 @@
+import { randomLetter } from '../src/utils'
+
+describe('randomLetter()', () => {
+  test('forceLength = false', () => {
+    const list = [...Array(1000)]
+
+    list.forEach(() => {
+      const letter = randomLetter()
+
+      expect(letter).toMatch(/^[A-Z]{1}$/)
+      expect(typeof letter).toBe('string')
+    })
+  })
+})

package/test/utils-removeFromPosition.test.ts

@@ -0,0 +1,15 @@
+import { removeFromPosition } from '../src/utils'
+
+describe('removeFromPosition()', () => {
+  test('', () => {
+    //
+    const list = [
+      { value: 'Jossé', start: 2, end: 3, expected: 'José' },
+      { value: 'Cláuudio', start: 4, end: 5, expected: 'Cláudio' },
+    ]
+
+    list.forEach((item) => {
+      expect(removeFromPosition(item.value, item.start, item.end)).toBe(item.expected)
+    })
+  })
+})

package/test/utils-sumElementsByMultipliers.test.ts

@@ -0,0 +1,24 @@
+import { sumElementsByMultipliers } from '../src/utils'
+
+describe('sumElementsByMultipliers()', () => {
+  test('Tipo do retorno', () => {
+    const sum = sumElementsByMultipliers('1234', [9, 8, 7, 6])
+
+    expect(typeof sum).toBe('number')
+    expect(sum).toBe(70)
+  })
+
+  test.each([
+    { input: '1234', multipliers: [9, 8, 7, 6], expected: 70 },
+    // cnpj
+    { input: '112223330001', multipliers: [5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2], expected: 102 },
+    // cpf
+    { input: '280012389', multipliers: [10, 9, 8, 7, 6, 5, 4, 3, 2], expected: 162 },
+    { input: '2800123893', multipliers: [11, 10, 9, 8, 7, 6, 5, 4, 3, 2], expected: 201 },
+    // titulo
+  ])('Valores retornados', (item) => {
+    const sum = sumElementsByMultipliers(item.input, item.multipliers)
+    expect(sum).toBe(item.expected)
+
+  })
+})

package/test/utils-sumToDV.test.ts

@@ -0,0 +1,16 @@
+import { sumToDV } from '../src/utils'
+
+describe('sumToDV()', () => {
+  test('Os resultados devem ser os esperados', () => {
+    const list = [
+      { value: 102, expected: 8 },
+      { value: 120, expected: 1 },
+      { value: 162, expected: 3 },
+      { value: 179, expected: 8 },
+    ]
+
+    list.forEach((item) => {
+      expect(sumToDV(item.value)).toBe(item.expected)
+    })
+  })
+})

package/todo.md

@@ -0,0 +1,18 @@
+- [x] isCarPlate
+
+- [x] isPhone
+
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isPhone.ts
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isDDD.ts
+
+- [ ] Conta bancária
+
+- [ ] isPixKey - verifica se é um dos tipos de chaves
+
+
+- [ ] isCEP
+  - https://github.com/ogilvieira/validator-brasil/blob/main/src/isCEP.ts
+
+- [ ] isCAEPF
+  - https://www.gov.br/receitafederal/pt-br/assuntos/orientacao-tributaria/cadastros/caepf/legislacao
+  - https://github.com/VitorLuizC/brazilian-values/blob/master/src/validators/isCAEPF.ts