validation-br 2.0.0-next-2 → 2.0.0-next-3

package/test/cbi_sinter.spec.ts

@@ -0,0 +1,69 @@
+import { CBISinter } from "../src/cbi_sinter";
+
+describe('CBISinter', () => {
+  describe('validate()', () => {
+    test('Deve validar um CIB válido com máscara (Exemplo Oficial)', () => {
+      const cbi = new CBISinter('A3N8Z4F-Y');
+      expect(cbi.value).toBe('A3N8Z4FY');
+    });
+
+    test('Deve validar um CIB válido sem máscara', () => {
+      const cbi = new CBISinter('A3N8Z4FY');
+      expect(cbi.value).toBe('A3N8Z4FY');
+    });
+
+    test('Deve validar um CIB válido com letras minúsculas', () => {
+      const cbi = new CBISinter('a3n8z4f-y');
+      expect(cbi.value).toBe('A3N8Z4FY');
+    });
+
+    test('Deve validar um CIB com substituições (I/L -> 1, O -> 0)', () => {
+      // Base '0000001' -> DV '8' (Cálculo: 1*8 = 8 % 31 = 8)
+      // Input 'O0O0O0L-8' -> Normaliza para '00000018'
+      const cbi = new CBISinter('O0O0O0L-8');
+      expect(cbi.value).toBe('00000018');
+    });
+
+    test('Deve lançar erro para CIB com DV inválido', () => {
+      expect(() => new CBISinter('A3N8Z4F-X')).toThrow();
+    });
+
+    test('Deve lançar erro para CIB com tamanho menor que o permitido', () => {
+      expect(() => new CBISinter('A3N8Z4')).toThrow();
+    });
+
+    test('Deve lançar erro para CIB com tamanho maior que o permitido', () => {
+      expect(() => new CBISinter('A3N8Z4FYA')).toThrow();
+    });
+
+    test('Deve lançar erro se contiver caractere proibido U', () => {
+      expect(() => new CBISinter('A3U8Z4F-Y')).toThrow();
+    });
+
+    test('Deve lançar erro para valor vazio', () => {
+      expect(() => new CBISinter('')).toThrow();
+    });
+  });
+
+  describe('checksum()', () => {
+    test('Deve calcular o DV corretamente (Exemplo da documentação)', () => {
+      expect(CBISinter.checksum('A3N8Z4F')).toBe('Y');
+    });
+
+    test('Deve lançar erro se valor vazio', () => {
+      expect(() => CBISinter.checksum('')).toThrow();
+    });
+
+    test('Deve lançar erro se formato inválido (tamanho incorreto)', () => {
+      expect(() => CBISinter.checksum('A3N8Z4')).toThrow();
+    });
+  });
+
+  describe('fake()', () => {
+    test.each([...Array(50)])('Deve gerar um CIB válido', () => {
+      const fake = CBISinter.fake();
+      
+      expect(() => new CBISinter(fake.value)).not.toThrow();
+    });
+  });
+});

package/test/cep.spec.ts

@@ -42,7 +42,10 @@ describe('CEP', () => {
       'CEP %s deve ser exibido sem máscara',
       (value) => {
         expect(new CEP(value).toString()).toBe('59650000');
+        expect(new CEP(value).toString()).toHaveLength(8)
+        
         expect(new CEP(value).value).toBe('59650000');
+        expect(new CEP(value).value).toHaveLength(8)
       }
     );
   });
@@ -53,6 +56,14 @@ describe('CEP', () => {
       expect(cep).toBeDefined();
       expect(cep.value).toHaveLength(8);
     });
+
+    test.each([...Array(5)])('Gera fake válido por estado', () => {
+      const cep = CEP.fake({ uf: UF.RN });
+      expect(cep).toBeDefined();
+      expect(cep.value).toHaveLength(8);
+      expect(cep.value >= '59000000').toBeTruthy();
+      expect(cep.value <= '59999999').toBeTruthy();
+    });
   });
 
   describe('checksum', () => {
@@ -103,6 +114,11 @@ describe('CEP', () => {
         expect(uf.value).toBe('SP');
       }
     );
+
+    test('Deve retornar erro para um CEP não encontrado', () => {
+      expect(() => CEP.getUFByCEP('00123456')).toThrow()
+    }
+    );
   });
 
   describe('getRandomByUF', () => {

package/test/certidao.spec.ts

@@ -0,0 +1,66 @@
+import { Certidao, CertidaoServico, CertidaoTipoLivro } from '../src/certidao';
+import { InvalidChecksumException } from '../src/_exceptions/ValidationBRError';
+
+describe('Certidao Class', () => {
+
+    test('deve normalizar o valor no construtor', () => {
+        // Gera um válido
+        const fake = Certidao.fake();
+        // Formata manualmente para testar a remoção
+        const formatted = fake.value.replace(/^(\d{6})(\d{2})(\d{2})/, '$1.$2-$3-'); // formatação parcial
+
+        const cert = new Certidao(formatted);
+        expect(cert.value).not.toContain('.');
+        expect(cert.value).not.toContain('-');
+        expect(cert.value).toBe(fake.value);
+    });
+
+    test('deve validar uma matrícula correta', () => {
+        const fake = Certidao.fake();
+        expect(fake.validate()).toBe(true);
+    });
+
+    test('deve lançar exceção para matrícula com DV errado', () => {
+        // 32 dígitos, mas final 99 provavelmente inválido para este prefixo
+        const invalid = '12345601552023100001001000000199';
+        expect(() => new Certidao(invalid)).toThrow(InvalidChecksumException);
+    });
+
+    test('deve aplicar a máscara corretamente', () => {
+        // Usar um válido para não lançar erro
+        const fake = Certidao.fake();
+        const v = fake.value;
+        // Máscara: 000000 00 00 0000 0 00000 000 0000000 00
+        //          012345 67 89 0123 4 56789 012 3456789 01
+        const expected = `${v.substring(0, 6)} ${v.substring(6, 8)} ${v.substring(8, 10)} ${v.substring(10, 14)} ${v.substring(14, 15)} ${v.substring(15, 20)} ${v.substring(20, 23)} ${v.substring(23, 30)} ${v.substring(30, 32)}`;
+
+        expect(fake.mask()).toBe(expected);
+    });
+
+    test('o método fake deve respeitar os parâmetros fornecidos', () => {
+        const anoPretendido = 1995;
+        const cert = Certidao.fake({
+            ano: anoPretendido,
+            servico: CertidaoServico.RegistroImoveis
+        });
+
+        expect(cert.value.substring(10, 14)).toBe('1995');
+        expect(cert.value.substring(8, 10)).toBe(CertidaoServico.RegistroImoveis);
+        expect(cert.validate()).toBe(true);
+    });
+
+    test('deve retornar string pura no toString()', () => {
+        const fake = Certidao.fake();
+        expect(fake.toString()).toBe(fake.value);
+    });
+
+    test('checksum estático deve calcular corretamente', () => {
+        // Teste direto do método estático
+        const base30 = '123456015520231000010010000001';
+        const dv = Certidao.checksum(base30);
+        expect(dv.length).toBe(2);
+        // Validar que o DV gerado cria um par válido
+        const cert = new Certidao(base30 + dv);
+        expect(cert.validate()).toBe(true);
+    });
+});

package/test/cnh.spec.ts

@@ -3,7 +3,11 @@ import * as _cnh from '../src/cnh';
 
 describe('CNH', () => {
   describe('constructor', () => {
-    test.each(['14490435923', '97286888262', '621049358-60', '491872350-50'])(
+    test.each([
+      '14490435923', 
+      '97286888262', 
+      '621049358-60', 
+      '491872350-50'])(
       'deve estar definido',
       (input) => {
         expect(new CNH(input)).toBeDefined();
@@ -64,4 +68,24 @@ describe('CNH', () => {
       expect(cnh.mask()).toMatch(/^\d{9}-\d{2}$/)
     });
   });
+
+  describe('toString', () => {
+    test.each([
+      { value: '14490435923', expected: '14490435923' },
+      { value: '97286888262', expected: '97286888262' },
+      { value: '621049358-60', expected: '62104935860' },
+      { value: '491.872.350-50', expected: '49187235050' },
+    ])('Deve ser exibido sem máscara', (input) => {
+      const cnh = new CNH(input.value);
+
+      expect(cnh.toString()).toBe(input.expected);
+      expect(cnh.toString()).toHaveLength(11);
+      
+      expect(cnh.value).toBe(input.expected);
+      expect(cnh.value).toHaveLength(11);
+      
+    });
+  });
+
+
 });

package/test/cnpj.spec.ts

@@ -56,7 +56,7 @@ describe('CNPJ', () => {
       expect(calcDv).toBe(item.expected);
       expect(typeof calcDv).toBe('string');
     });
-    
+
     test.each(['11222333000', '1122233300011', ''])(
       'deve lançar erro de dv',
       (item) => {
@@ -124,4 +124,30 @@ describe('CNPJ', () => {
     );
 
   });
+
+  describe('toString', () => {
+    test.each([
+      { input: '11.222.333/0001-81', expected: '11222333000181' },
+      { input: '73.797.980/0001-79', expected: '73797980000179' },
+      { input: '06.946.762/0001-61', expected: '06946762000161' },
+      { input: '96.051.576/0001-57', expected: '96051576000157' },
+      { input: '55.585.709/0001-98', expected: '55585709000198' },
+      { input: '99360938000180', expected: '99360938000180' },
+      { input: '23693443000100', expected: '23693443000100' },
+      { input: '32432147000147', expected: '32432147000147' },
+      { input: '91951438000100', expected: '91951438000100' },
+    ])('deve estar definido', (input) => {
+      const cnpj = new CNPJ(input.input);
+      expect(cnpj.toString()).toBe(input.expected);
+      expect(cnpj.toString()).toHaveLength(14);
+      
+      expect(cnpj.value).toBe(input.expected);
+      expect(cnpj.value).toHaveLength(14);
+    });
+  });
+
+
 });
+
+
+

package/test/cpf.spec.ts

@@ -37,7 +37,7 @@ describe('CPF', () => {
       { 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) => {    
+    ])('mask() - Testando se a máscara foi gerada corretamente', (item) => {
       const masked = new CPF(item.num).mask();
 
       expect(masked).toBe(item.expected);
@@ -64,7 +64,7 @@ describe('CPF', () => {
       expect(typeof calcDv).toBe('string');
     });
 
-    
+
     test.each(['74172316', '1588648900', ''])(
       '%s deve lançar erro de dv',
       (item) => {
@@ -73,4 +73,16 @@ describe('CPF', () => {
     );
 
   });
+
+  describe('toString', () => {
+    test('Deve exibir o valor sem os caracteres especiais', () => {
+      const cpf = new CPF('133.782.710-00');
+      
+      expect(cpf.toString()).toBe('13378271000')
+      expect(cpf.toString()).toHaveLength(11)
+      
+      expect(cpf.value).toBe('13378271000')
+      expect(cpf.value).toHaveLength(11)
+    });
+  });
 });

package/test/email.spec.ts

@@ -0,0 +1,19 @@
+import { Email } from "../src/email";
+
+describe('Email', () => {
+  describe('constructor', () => {
+    test('Deve definir um email', () => {
+      const email = new Email('klawdyo@gmail.com');
+      expect(email).toBeDefined()
+    });
+  });
+
+  describe('fake', () => {
+    test('Deve definir um email fake', () => {
+      const email = Email.fake();
+      
+      expect(new Email(email.toString())).toBeDefined()
+      expect(new Email(email.value)).toBeDefined()
+    });
+  });
+});

package/test/judicial-process.spec.ts

@@ -1,4 +1,5 @@
 import { JudicialProcess } from '../src/judicial-process';
+import { insertAtPosition } from '../src/_helpers/utils';
 
 describe('JudicialProcess', () => {
   describe('constructor', () => {
@@ -8,13 +9,13 @@ describe('JudicialProcess', () => {
       '08002785520134058400',
       '08002732820164058400',
     ])('deve estar definido', (input) => {
-      // console.log(new JudicialProcess(input));
-
-      expect(new JudicialProcess(input)).toBeDefined();
+      const proc = new JudicialProcess(input)
+      expect(proc).toBeDefined();
+      expect(proc.processNumber).toBe(input.replace(/\D/g, '').substring(0, 7))
     });
 
     test.each([
-      '0110060720168200100',
+      '0110060720168200100', // caractere a menos
       '61052838320098130023',
       '00110060720168200102',
       '08002785520134058401',
@@ -108,19 +109,24 @@ describe('JudicialProcess', () => {
 
   describe('checksum', () => {
     test.each([
-      { num: '000208020125150049', expected: '25' },
-      { num: '610528320098130024', expected: '83' },
-      { num: '001100620168200100', expected: '07' },
-      { num: '080027820134058400', expected: '55' },
-      { num: '080027320164058400', expected: '28' },
+      { num: '000208020125150049', dv: '25' },
+      { num: '610528320098130024', dv: '83' },
+      { num: '001100620168200100', dv: '07' },
+      { num: '080027820134058400', dv: '55' },
+      { num: '080027320164058400', dv: '28' },
     ])('dv() - Verificando se o DV gerado está correto', (item) => {
       const calcDv = JudicialProcess.checksum(item.num);
 
-      expect(calcDv).toBe(item.expected);
+      expect(calcDv).toBe(item.dv);
       expect(typeof calcDv).toBe('string');
+
+      // Preenche número do processo com o seu DV
+      const full = insertAtPosition(item.num, item.dv, 7)
+      expect(new JudicialProcess(full).checksum).toBe(item.dv)
+
     });
 
-        
+
     test.each(['0002080201251500499', '00020802012515004', ''])(
       'deve lançar erro de dv',
       (item) => {
@@ -128,4 +134,55 @@ describe('JudicialProcess', () => {
       }
     );
   });
+
+  describe('toString', () => {
+    test.each([
+      { input: '6105283-83.2009.8.13.0024', expected: '61052838320098130024', },
+      { input: '00110060720168200100', expected: '00110060720168200100', },
+      { input: '08002785520134058400', expected: '08002785520134058400', },
+      { input: '08002732820164058400', expected: '08002732820164058400', },
+    ])('deve exibir o valor sem caracteres especiais', (input) => {
+      
+      const proc = new JudicialProcess(input.input)
+      
+      expect(proc.toString()).toBe(input.expected)
+      expect(proc.toString()).toHaveLength(20)
+      
+      expect(proc.value).toBe(input.expected)
+      expect(proc.value).toHaveLength(20)
+    });
+
+
+  });
+
+  describe('getWithoutChecksum', () => {
+    test('Deve pegar o número completo do processo sem o DV', () => {
+      // expect(new JudicialProcess('00020802520125150049').)
+      expect(JudicialProcess.getWithoutChecksum('00020802520125150049')).toBe('000208020125150049')
+      expect(JudicialProcess.getWithoutChecksum('000208020125150049')).toBe('000208020125150049')
+      expect(() => JudicialProcess.getWithoutChecksum('00020802012515004')).toThrow()
+    });
+  })
+
+  describe('getFakeSubCourt', () => {
+    test('Deve pegar aleatoriamente uma subcorte', () => {
+      // se informar zero, use 01
+      expect(JudicialProcess.getFakeSubCourt('0')).toBe('01')
+      expect(JudicialProcess.getFakeSubCourt('00')).toBe('01')
+      // vazio calcula um aleatorio
+      expect(JudicialProcess.getFakeSubCourt('').length).toBe(2)
+      expect(JudicialProcess.getFakeSubCourt(null as any).length).toBe(2)
+      expect(JudicialProcess.getFakeSubCourt(undefined as any).length).toBe(2)
+      // se informar um válido, use ele mesmo
+      expect(JudicialProcess.getFakeSubCourt('02')).toBe('02')
+      // se informar um inválido, use 01
+      expect(JudicialProcess.getFakeSubCourt('345')).toBe('01')
+
+      const fake = JudicialProcess.getFakeSubCourt();
+
+      expect(fake.length).toBe(2);
+      expect(fake >= '01').toBeTruthy();
+      expect(fake <= '99').toBeTruthy();
+    });
+  })
 });

package/test/nup17.spec.ts

@@ -76,4 +76,24 @@ describe('NUP17', () => {
       }
     );
   });
+
+ describe('toString', () => {
+    test.each([
+      { input: '23037001380202111',    expected: '23037001380202111' },
+      { input: '23037001434202148',    expected: '23037001434202148' },
+      { input: '23037001321202142',    expected: '23037001321202142' },
+      { input: '23037.001462/2021-65', expected: '23037001462202165' },
+      { input: '23037.001537/2021-16', expected: '23037001537202116' },
+      { input: '23037.001086/2021-17', expected: '23037001086202117' },
+    ])('Deve exibir o valor sem o caracteres especiais', (item) => {
+      const nup = new NUP17(item.input);
+
+      expect(nup.toString()).toBe(item.expected);
+      expect(nup.toString()).toHaveLength(17);
+
+      expect(nup.value).toBe(item.expected);
+      expect(nup.value).toHaveLength(17);
+    });
+  });
+
 });

package/test/phone.spec.ts

@@ -1,11 +1,11 @@
 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',
+  '+5584999873456',
+  '+55 84 9 9987 3456',
+  '+55 (84) 9 9987-3456',
+  '+55 (84) 99987-3456',
+  '84 99987-3456',
 ];
 const phones = [
   '+558433311454',
@@ -19,10 +19,10 @@ 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.value).toBe('+5584999873456');
       expect(obj.ddi).toBe('+55');
       expect(obj.ddd).toBe('84');
-      expect(obj.phone).toBe('999580685');
+      expect(obj.phone).toBe('999873456');
       expect(obj.isMobile).toBeTruthy();
     });
 
@@ -34,6 +34,10 @@ describe('Phone', () => {
       expect(obj.phone).toBe('33311454');
       expect(obj.isMobile).toBeFalsy;
     });
+
+    test.each(['12', '1234567890000', '00999870222'])('Deve lançar exceção', (value) => {
+      expect(() => new Phone(value)).toThrow();
+    });
   });
 
   describe('fake', () => {
@@ -48,6 +52,10 @@ describe('Phone', () => {
       expect(fake.ddd).toBe('11');
     });
 
+    test('Cria um fake com DDD inválido', () => {
+      expect(() => Phone.fake({ ddd: '10' })).toThrow();
+    });
+
     test.each([...Array(5)])('Cria um fake com isMobile=true', () => {
       const fake = Phone.fake({ isMobile: true });
       expect(fake).toBeDefined();
@@ -66,12 +74,12 @@ describe('Phone', () => {
   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');
+      expect(phone.mask({ withCountry: false })).toBe('84 999873456');
     });
 
     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');
+      expect(phone.mask({ withCountry: true })).toBe('+55 84 999873456');
     });
 
     test.each(phones)('Máscara de telefone fixo sem país', (input) => {
@@ -84,4 +92,22 @@ describe('Phone', () => {
       expect(phone.mask({ withCountry: true })).toBe('+55 84 33311454');
     });
   });
+
+  describe('checksum', () => {
+    expect(() => Phone.checksum()).toThrow()
+  })
+
+  describe('toString', () => {
+    test.each([...phones, ...cellPhones])('Deve exibir o valor sem o caracteres especiais', (input) => {
+      const phone = new Phone(input);
+      const cleared = phone.value.replace(/[()\s-]+/g, '');
+
+      expect(phone.toString()).toBe(cleared)
+      expect(phone.toString()).toHaveLength(cleared.length)
+
+
+      expect(phone.value).toBe(cleared)
+      expect(phone.value).toHaveLength(cleared.length)
+    });
+  });
 });

package/test/pis-pasep.spec.ts

@@ -70,4 +70,23 @@ describe('PIS', () => {
       }
     );
   });
+
+  describe('toString', () => {
+    test.each([
+      { input: '71282677380',    expected: '71282677380', },
+      { input: '23795126955',    expected: '23795126955', },
+      { input: '50012973803',    expected: '50012973803', },
+      { input: '27890141144',    expected: '27890141144', },
+      { input: '268.27649.96-0', expected: '26827649960', },
+      { input: '613.01862.91-7', expected: '61301862917', },
+    ])('Deve exibir o valor sem o caracteres especiais', (item) => {
+      const pis = new PIS(item.input);
+      
+      expect(pis.toString()).toBe(item.expected);
+      expect(pis.toString()).toHaveLength(11);
+      
+      expect(pis.value).toBe(item.expected);
+      expect(pis.value).toHaveLength(11);
+    });
+  });
 });

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

@@ -1,13 +1,13 @@
 // pix usado pelo 10 pila.
 
-import { PixCopyPaste } from '../src/pix-copy-paste';
+import { PixCopyPaste, PixPart } 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, 
+  pixStone,
   pixManual
 ]
 
@@ -18,19 +18,39 @@ describe('PixCopyPaste', () => {
       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()
+      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();
+  describe('PixPart', () => {
+    describe('parse', () => {
+      test.each(cases)('testa o parse', (input) => {
+        const parse = PixPart.parse(input);
+
+        expect(parse).toBeDefined();
+        expect(Array.isArray(parse)).toBeTruthy();
+      });
+    });
+
+    describe('getPart', () => {
+      test.each([
+        '', // vazio
+        '123', // menos de 3 números
+        'acvs', // não começa com 4 números
+
+      ])('deve retornar um valor padrão', (part) => {
+        const expected = { part, code: '', size: 0, value: '', rest: part, children: [] }
+        expect(PixPart.getPart(part)).toMatchObject(expected);
+      });
+
+      test.each([
+        '0002a', // a partir do quinto valor não tem o mesmo tamanho definido nas posições 3 e 4
+      ])('deve retornar um erro', (part) => {
+        expect(() => PixPart.getPart(part)).toThrow();
+      });
     });
   });
 });

package/test/pix-key.spec.ts

@@ -1,6 +1,6 @@
 import { PixKey, PixKeys } from '../src/pix-key';
 
-describe('Pix', () => {
+describe('PixKey', () => {
   describe('constructor', () => {
     test('deve estar definido do tipo e-mail', () => {
       const key = new PixKey('klawdyo@gmail.com');
@@ -35,7 +35,41 @@ describe('Pix', () => {
     test('deve falhar ao receber um telefone inválido', () => {
       expect(() => new PixKey('+55849876')).toThrow()
     });
+  });
 
+  describe('Máscara', () => {
+    test('Deve retornar o mesmo valor', () => {
+      const input = 'klawdyo@gmail.com';
+      // const masked = 
+      expect(new PixKey(input).mask()).toBe(input);
+    });
+  });
+
+  describe('Fake', () => {
+    test('Deve retornar um valor fake que é um email', () => {
+      const value = PixKey.fake({ type: PixKeys.email });
+      expect(value.type).toBe(PixKeys.email);
+    });
+    test('Deve retornar um valor fake que é um cpf', () => {
+      const value = PixKey.fake({ type: PixKeys.cpf });
+      expect(value.type).toBe(PixKeys.cpf);
+    });
+    test('Deve retornar um valor fake que é um cnpj', () => {
+      const value = PixKey.fake({ type: PixKeys.cnpj });
+      expect(value.type).toBe(PixKeys.cnpj);
+    });
+    test('Deve retornar um valor fake que é um phone', () => {
+      const value = PixKey.fake({ type: PixKeys.phone });
+      expect(value.type).toBe(PixKeys.phone);
+    });
+    test('Deve retornar um valor fake que é um evp', () => {
+      const value = PixKey.fake({ type: PixKeys.evp });
+      expect(value.type).toBe(PixKeys.evp);
+    });
 
+    test.each([...Array(100)])('Deve criar uma chave fake válida', () => {
+      const value = PixKey.fake().toString();
+      expect(new PixKey(value)).toBeDefined();
+    });
   });
 });