validation-br 0.8.3 → 1.0.0-b

package/src/renavam.test.ts

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

package/src/renavam.ts

@@ -0,0 +1,122 @@
+/**
+ * RENAVAM
+ * Funções auxiliares para cálculo de máscaras, validação, dígito verificador e criaçãode
+ * números fake.
+ *
+ * @doc
+ * - O número de RENAVAM deve possuir 11 caracteres
+ *
+ * - Os caracteres de 1 a 10 são a numeração documento
+ *
+ * - O caractere 11 é o dígito verificador.
+ *
+ * 1) Partes do número
+ *  _______________________________________________
+ * |  Número                                 | D V |
+ * |  2   6   8   2   7   6   4   9   9   6  -  0  |
+ * |_________________________________________|_____|
+ *
+ * 2) Cálculo do DV.
+ *
+ *  - Soma-se o produto das algarismos 3 a 10 pelos números 3, 2, 9, 8, 7, 6, 5, 4, 3, 2
+ *
+ *    2   6   8   2   7   6   4   9   9   6
+ *    x   x   x   x   x   x   x   x   x   x
+ *    3   2   9   8   7   6   5   4   3   2
+ * =  6 +12 +72 +16 +49 +12 +20 +36 +27 +12  =  234
+ *
+ *  - O somatório encontrado é multiplicado por 10 e ao resultado
+ *    é aplicado o cálculo do MOD 11.
+ *
+ *    ( 234 * 10 ) / 11 tem resto 8. DV = 8. Caso o resto seja maior ou igual a
+ *    10, DV será 0.
+ *
+ *
+ */
+
+import {
+  sumElementsByMultipliers,
+  clearValue,
+  fakeNumber,
+  applyMask,
+  invalidListGenerator,
+} from './utils'
+
+/**
+ * dv()
+ * Calcula o dígito verificador
+ *
+ * @param {Number|String} value
+ * @returns {String}
+ */
+export const dv = (value: string | number): string => {
+  if (!value) throw new Error('Renavam não informado')
+
+  const renavam = clearValue(value, 10) // só 10 para remover o DV
+
+  const invalidList = invalidListGenerator(10)
+  if (invalidList.includes(renavam)) {
+    throw new Error('RENAVAM não pode ser uma sequência de números iguais')
+  }
+
+  const sum1 = sumElementsByMultipliers(renavam, [3, 2, 9, 8, 7, 6, 5, 4, 3, 2]) * 10
+  const dv1 = sum1 % 11 >= 10 ? 0 : sum1 % 11
+  return `${dv1}`
+}
+
+/**
+ * Aplica uma máscara ao número informado
+ *
+ * @param {String} value Número de Processo
+ * @returns {String} Valor com a máscara
+ */
+export const mask = (value: string | number): string => applyMask(value, '0000000000-0')
+
+/**
+ * fake()
+ * Gera um número válido
+ *
+ * @returns {String}
+ */
+export const fake = (withMask: boolean = false): string => {
+  const value = fakeNumber(10, true)
+
+  const renavam = `${value}${dv(value)}`
+
+  if (withMask) return mask(renavam)
+
+  return renavam
+}
+
+/**
+ * validateOrFail()
+ * Valida se um número de processo está correto e
+ * retorna uma exceção se não estiver
+ *
+ * @returns {Boolean}
+ */
+export const validateOrFail = (value: string | number): boolean => {
+  const renavam = clearValue(value, 11)
+
+  if (dv(renavam) !== renavam.substring(10, 11)) {
+    throw new Error('Dígito verificador inválido')
+  }
+
+  return true
+}
+
+/**
+ * validate()
+ * Valida se um número de processo está correto
+ *
+ * @returns {Boolean}
+ */
+export const validate = (value: string | number): boolean => {
+  try {
+    return validateOrFail(value)
+  } catch (error) {
+    return false
+  }
+}
+
+export default validate

package/src/tituloEleitor.test.ts

@@ -0,0 +1,129 @@
+import isTituloEleitor, { dv, fake, mask, validate, validateOrFail } from './tituloEleitor'
+
+describe('TituloEleitor', () => {
+  test('isTituloEleitor() - Números válidos', () => {
+    const list = [
+      // masked
+      '1023.8501.0671',
+      '8365.7137.1619',
+      // string
+      '153036161686',
+      '525028881694',
+      // integer
+      11122223360,
+      1122223336,
+    ]
+
+    list.forEach((tituloEleitor) => {
+      expect(isTituloEleitor(tituloEleitor)).toBeTruthy()
+    })
+  })
+
+  test('validate() - Números válidos', () => {
+    const list = [
+      // masked
+      '1023.8501.0671',
+      '8365.7137.1619',
+      // string
+      '153036161686',
+      '525028881694',
+      // integer
+      11122223360,
+      1122223336,
+    ]
+
+    list.forEach((tituloEleitor) => {
+      expect(validate(tituloEleitor)).toBeTruthy()
+    })
+  })
+
+  test('validate() - Números inválidos', () => {
+    const list = [
+      '836531371619',
+      '743620641660',
+      '153016161686',
+      '525078881694',
+      '026367681660',
+      '558647441635',
+      '222222222222',
+    ]
+
+    list.forEach((tituloEleitor) => {
+      expect(validate(tituloEleitor)).toBeFalsy()
+    })
+  })
+
+  test('validateOrFail() - Números inválidos', () => {
+    const list = [
+      '836531371619',
+      '743620641660',
+      '153016161686',
+      '525078881694',
+      '026367681660',
+      '558647441635',
+      '222222222222',
+    ]
+
+    list.forEach((tituloEleitor) => {
+      expect(() => validateOrFail(tituloEleitor)).toThrow()
+    })
+  })
+
+  test('Parâmetro não informado', () => {
+    expect(isTituloEleitor('')).toBeFalsy()
+    expect(validate('')).toBeFalsy()
+    expect(() => validateOrFail('')).toThrow()
+    expect(() => dv('')).toThrow()
+  })
+
+  test('fake() - Gera fakes sem máscara', () => {
+    for (let i = 0; i < 5; i += 1) {
+      const tituloEleitor = fake()
+
+      expect(validate(tituloEleitor)).toBeTruthy()
+      expect(tituloEleitor).toHaveLength(12)
+    }
+  })
+
+  test('fake() - Gera fakes com máscara', () => {
+    for (let i = 0; i < 5; i += 1) {
+      const tituloEleitor = fake(true)
+
+      expect(validate(tituloEleitor)).toBeTruthy()
+      expect(tituloEleitor).toHaveLength(14)
+    }
+  })
+
+  test('dv() - Verificando se o DV gerado está correto', () => {
+    const list = [
+      { num: '1023850106', expected: '71' },
+      { num: '8365713716', expected: '19' },
+      { num: '7436506416', expected: '60' },
+      { num: 11222233, expected: '36' },
+    ]
+
+    list.forEach((item) => {
+      const calcDv = dv(item.num)
+
+      expect(calcDv).toBe(item.expected)
+      expect(typeof calcDv).toBe('string')
+    })
+  })
+
+  test('mask() - Testando se a máscara foi gerada corretamente', () => {
+    const list = [
+      { num: '102385010671', expected: '1023.8501.0671' },
+      { num: '836571371619', expected: '8365.7137.1619' },
+      { num: '743650641660', expected: '7436.5064.1660' },
+      { num: 11122223360, expected: '0111.2222.3360' },
+      { num: 1122223336, expected: '0011.2222.3336' },
+    ]
+
+    list.forEach((item) => {
+      const masked = mask(item.num)
+
+      expect(masked).toBe(item.expected)
+      expect(masked).toHaveLength(14)
+    })
+  })
+})

package/src/tituloEleitor.ts

@@ -0,0 +1,146 @@
+/**
+ * isTitulo()
+ * Calcula se um título eleitoral é válido
+ *
+ * @doc
+ * Título de eleitor deve possuir 12 dígitos.
+ *
+ * - Os caracteres 1 a 8 são números sequenciais.
+ *
+ * - Os caracteres 9 e 10 representam os estados da federação onde o título
+ *   foi emitido (01 = SP, 02 = MG, 03 = RJ, 04 = RS, 05 = BA, 06 = PR, 07 = CE, 08 = PE,
+ *   09 = SC, 10 = GO,  11 = MA12 = PB, 13 = PA, 14 = ES, 15 = PI, 16 = RN, 17 = AL,
+ *   18 = MT, 19 = MS, 20 = DF, 21 = SE, 22 = AM, 23 = RO, 24 = AC, 25 = AP, 26 = RR,
+ *   27 = TO, 28 = Exterior(ZZ).
+ *
+ * - Os caracteres 11 e 12 são dígitos verificadores.
+ *
+ * 1) Partes do número
+ * ------------------------------------------------
+ * |       Número Sequencial      |  UF   |   DV  |
+ *  1   0   2   3   8   5   0   1   0   6   7   1
+ *
+ * 2) Cálculo do primeiro DV.
+ *
+ *  - Soma-se o produto das algarismos 1 a 8 pelos números 2, 3, 4, 5, 6, 7, 8 e 9.
+ *
+ *   1   0   2   3   8   5   0   1
+ *   x   x   x   x   x   x   x   x
+ *   2   3   4   5   6   7   8   9
+ * = 2 + 0 + 8 +15 +48 +35 + 0 + 9  = 117
+ *
+ *  - O somatório encontrado é dividido por 11. O DV1 é o resto da divisão. Se o
+ *    resto for 10, o DV1 é 0.
+ *
+ * 2.1) 117 / 11 tem resto igual a 7.
+ *
+ * 3) Cálculo do segundo DV
+ *
+ * - Soma-se o produto dos algarismos 9 a 11 (relativos aos 2 dígitos da UF e o novo
+ *   DV1 que acabou de ser calculado) e os multiplicam pelos números 7, 8 e 9. Se o
+ *   resto for 10, DV2 será 0.
+ *   0   6   7
+ *   x   x   x
+ *   7   8   9
+ * = 0 +48 +63 = 111
+ *
+ * 3.1) 111 / 11 tem resto igual a 1.
+ *
+ * Fonte: http://clubes.obmep.org.br/blog/a-matematica-nos-documentos-titulo-de-eleitor/
+ *
+ * @param {String} value Título eleitoral
+ * @returns {Boolean}
+ */
+
+import {
+  sumElementsByMultipliers,
+  clearValue,
+  fakeNumber,
+  applyMask,
+  invalidListGenerator,
+} from './utils'
+
+/**
+ * dv()
+ * Calcula o dígito verificador
+ *
+ * @param {Number|String} value
+ * @returns {String}
+ */
+export const dv = (value: string | number): string => {
+  if (!value) throw new Error('CPF não informado')
+
+  const titulo = clearValue(value, 10)
+
+  const invalidList = invalidListGenerator(10)
+  if (invalidList.includes(titulo)) {
+    throw new Error('Título não pode ser uma sequência de números iguais')
+  }
+
+  const sum1 = sumElementsByMultipliers(titulo.substring(0, 8), [2, 3, 4, 5, 6, 7, 8, 9])
+  const dv1 = sum1 % 11 >= 10 ? 0 : sum1 % 11
+
+  const sum2 = sumElementsByMultipliers(titulo.substring(8, 10) + dv1, [7, 8, 9])
+  const dv2 = sum2 % 11 >= 10 ? 0 : sum2 % 11
+
+  return `${dv1}${dv2}`
+}
+
+/**
+ * Aplica uma máscara ao número informado
+ *
+ * @param {String} value Número de Processo
+ * @returns {String} Valor com a máscara
+ */
+export const mask = (value: string | number): string => applyMask(value, '0000.0000.0000')
+// const mask = (value) => applyMask(value, '0000.0000.0000');
+
+/**
+ * fake()
+ * Gera um número válido
+ *
+ * @returns {String}
+ */
+export const fake = (withMask: boolean = false): string => {
+  const num = fakeNumber(8, true)
+
+  const uf = (Math.random() * 27 + 1).toFixed(0).padStart(2, '0')
+
+  const titulo = `${num}${uf}${dv(num + uf)}`
+
+  if (withMask) return mask(titulo)
+  return titulo
+}
+
+/**
+ * validateOrFail()
+ * Valida se um número de processo está correto e
+ * retorna uma exceção se não estiver
+ *
+ * @returns {Boolean}
+ */
+export const validateOrFail = (value: string | number): boolean => {
+  const titulo = clearValue(value, 12)
+
+  if (dv(titulo) !== titulo.substring(10, 12)) {
+    throw new Error('Dígito verificador inválido')
+  }
+
+  return true
+}
+
+/**
+ * validate()
+ * Valida se um número de processo está correto
+ *
+ * @returns {Boolean}
+ */
+export const validate = (value: string | number): boolean => {
+  try {
+    return validateOrFail(value)
+  } catch (error) {
+    return false
+  }
+}
+
+export default validate

package/src/utils-applyMask.test.ts

@@ -0,0 +1,17 @@
+const { applyMask } = require('./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/src/utils-clearValue.test.ts

@@ -0,0 +1,55 @@
+import { clearValue } from './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)).toBe(item.expected)
+    })
+  })
+
+  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)).toBe(item.expected)
+    })
+  })
+})

package/src/utils-fakeNumber.test.ts

@@ -0,0 +1,19 @@
+const { fakeNumber } = require('./utils')
+
+describe('fakeNumber()', () => {
+  test('forceLength = true', () => {
+    const num = fakeNumber(4, true)
+
+    expect(num).toHaveLength(4)
+    expect(typeof num).toBe('string')
+    expect(num).toMatch(/^[\d]+$/)
+  })
+
+  test('forceLength = false', () => {
+    const num = fakeNumber(4)
+
+    expect(num).toBeLessThanOrEqual(9999)
+    expect(num).toBeGreaterThanOrEqual(0)
+    expect(typeof num).toBe('number')
+  })
+})

package/src/utils-insertAtPosition.test.ts

@@ -0,0 +1,15 @@
+import { insertAtPosition } from './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/src/utils-invalidListGenerator.test.ts

@@ -0,0 +1,27 @@
+const { invalidListGenerator } = require('./utils')
+
+describe('invalidListGenerator()', () => {
+  test('invalidListGenerator - Número de itens', () => {
+    const list = invalidListGenerator(4)
+
+    expect(1).toBe(1)
+    expect(Array.isArray(list)).toBeTruthy()
+  })
+
+  test('invalidListGenerator - Tamanho dos itens', () => {
+    const valid = [
+      { length: 10, size: 8 },
+      { length: 10, size: 4 },
+    ]
+
+    valid.forEach((item) => {
+      const list = invalidListGenerator(item.size)
+
+      expect(list).toHaveLength(10)
+
+      list.forEach((num: string) => {
+        expect(num).toHaveLength(item.size)
+      })
+    })
+  })
+})

package/src/utils-removeFromPosition.test.ts

@@ -0,0 +1,15 @@
+import { removeFromPosition } from './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/src/utils-sumElementsByMultipliers.test.ts

@@ -0,0 +1,34 @@
+const { sumElementsByMultipliers } = require('./utils')
+
+describe('sumElementsByMultipliers()', () => {
+  test('Tipo do retorno', () => {
+    const sum = sumElementsByMultipliers('1234', '9876')
+
+    expect(typeof sum).toBe('number')
+    expect(sum).toBe(70)
+  })
+
+  test('Valores retornados', () => {
+    ;[
+      { input: '1234', multipliers: '9876', expected: 70 },
+      { 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 },
+      { input: '1122233300018', multipliers: '6543298765432', expected: 120 },
+      // 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
+      { input: '10238501', multipliers: '23456789', expected: 117 },
+      { input: '067', multipliers: '789', expected: 111 },
+    ].forEach((item) => {
+      const sum = sumElementsByMultipliers(item.input, item.multipliers)
+      expect(sum).toBe(item.expected)
+    })
+
+    const sum = sumElementsByMultipliers('1234', '9876')
+
+    expect(typeof sum).toBe('number')
+    expect(sum).toBe(70)
+  })
+})