Resolve #67

.coveragerc

@@ -1,8 +1,11 @@
 [run]
 source = validate_docbr
 disable_warnings = no-data-collected
+omit = validate_docbr/exceptions.py
 
 [report]
-fail_under = 97.50
+fail_under = 98.00
 precision = 2
 show_missing = True
+exclude_lines =
+    raise FunctionNotImplementedError

.githooks/pre-push

@@ -1,23 +1,14 @@
-#!/bin/sh
+#!/bin/bash
 
-warning() {
-  # shellcheck disable=2028
-  echo "\\e[1;33m$1"
+handle_failure() {
+  echo "❌ Error: $1 failed!"
+  exit 1
 }
 
-alertMessages() {
-  warning "One or more $1 are failing."
-  warning "Please fix those $1 before pushing your branch"
-}
+echo "🔍 Running lint checks..."
+make lint || handle_failure "lint"
 
-if make lint; then
-  if make test-coverage; then
-    exit 0
-  else
-    alertMessages "unit tests"
-    exit 1
-  fi
-else
-  alertMessages "linter checks"
-  exit 1
-fi
+echo "🧪 Running test coverage..."
+make test-coverage || handle_failure "test-coverage"
+
+echo "✅ All checks passed successfully!"

Makefile

@@ -33,6 +33,11 @@ lint:
 		&& lint-shell-script \
 		&& lint-python"
 
+.PHONY: lint-fix
+lint-fix:
+	@docker pull ${DOCKER_IMAGE_LINTER}
+	@docker run --rm -v ${ROOT}:/app ${DOCKER_IMAGE_LINTER} "lint-python-fix"
+
 .PHONY: test
 test:
 	@docker compose run --rm -v ${ROOT}:/app \
@@ -41,7 +46,7 @@ test:
 
 .PHONY: test-coverage
 test-coverage:
-	@docker compose run --rm -v ${ROOT}:/app \
+	@docker compose run --rm -T -v ${ROOT}:/app \
 		--name ${TEST_CONTAINER_NAME} ${APP_NAME} \
 		/bin/bash -c "pytest --cov=validate_docbr/"
 

tests/test_CNH.py

@@ -4,34 +4,41 @@
 
 
 class TestCnh(unittest.TestCase):
-    """Testar a classe CNH."""
+    """Testa a classe CNH."""
 
     def setUp(self):
-        """Inicia novo objeto em todo os testes."""
         self.cnh = docbr.CNH()
 
-    def test_generate_validate(self):
-        """Verifica os métodos de geração e validação de documento."""
-        # generate_list
+    def test_generate_list_with_validate_list(self):
+        # Given
+        number_of_documents = 10
+        number_of_documents_expected = number_of_documents * 2
+
+        # When
         cnhs = (
-                self.cnh.generate_list(1)
-                + self.cnh.generate_list(1, mask=True)
-                + self.cnh.generate_list(1, mask=True, repeat=True)
+                self.cnh.generate_list(number_of_documents)
+                + self.cnh.generate_list(number_of_documents, mask=True)
         )
-        self.assertIsInstance(cnhs, list)
-        self.assertTrue(len(cnhs) == 3)
+        validated_cnhs = self.cnh.validate_list(cnhs)
 
-        # validate_list
-        cnhs_validates = self.cnh.validate_list(cnhs)
-        self.assertTrue(sum(cnhs_validates) == 3)
+        # Then
+        self.assertIsInstance(cnhs, list)
+        self.assertTrue(len(cnhs) == number_of_documents_expected)
+        self.assertTrue(sum(validated_cnhs) == number_of_documents_expected)
 
     def test_mask(self):
-        """Verifica se o método mask funciona corretamente."""
-        masked_cpf = self.cnh.mask('11122233344')
-        self.assertEqual(masked_cpf, '111 222 333 44')
+        # Given
+        doc = '11122233344'
+        doc_expected = '111 222 333 44'
+
+        # When
+        masked_cpf = self.cnh.mask(doc)
+
+        # Then
+        self.assertEqual(masked_cpf, doc_expected)
 
     def test_special_case(self):
-        """ Verifica os casos especiais de CNH """
+        # Given
         cases = [
             ('00000000000', False),
             ('AAAAAAAAAAA', False),
@@ -42,5 +49,10 @@ def test_special_case(self):
             ('10764125809', True),
             ('77625261946', True)
         ]
+
+        # When
         for cnh, is_valid in cases:
-            self.assertEqual(self.cnh.validate(cnh), is_valid)
+            doc_validated = self.cnh.validate(cnh)
+
+            # Then
+            self.assertEqual(doc_validated, is_valid)

tests/test_CNPJ.py

@@ -4,71 +4,80 @@
 
 
 class TestCnpj(unittest.TestCase):
-    """Testar a classe CNPJ."""
+    """Testa a classe CNPJ."""
 
     def setUp(self):
-        """Inicia novo objeto em todo os testes."""
         self.cnpj = docbr.CNPJ()
 
-    def test_generate_validate(self):
-        """Verifica os métodos de geração e validação de documento."""
-        # generate_list
-        cnpjs = self.cnpj.generate_list(5000) \
-                + self.cnpj.generate_list(5000, mask=True) \
-                + self.cnpj.generate_list(5000, mask=True, repeat=True)
+    def test_generate_list_with_validate_list(self):
+        # Given
+        number_of_documents = 10
+        number_of_documents_expected = number_of_documents * 2
+
+        # When
+        cnpjs = self.cnpj.generate_list(number_of_documents) \
+                + self.cnpj.generate_list(number_of_documents, mask=True)
+        validated_cnpjs = self.cnpj.validate_list(cnpjs)
+
+        # Then
         self.assertIsInstance(cnpjs, list)
-        self.assertTrue(len(cnpjs) == 15000)
-
-        # validate_list
-        cnpjs_validates = self.cnpj.validate_list(cnpjs)
-        self.assertTrue(sum(cnpjs_validates) == 15000)
+        self.assertTrue(len(cnpjs) == number_of_documents_expected)
+        self.assertTrue(sum(validated_cnpjs) == number_of_documents_expected)
 
     def test_mask(self):
-        """Verifica se o método mask funciona corretamente."""
-        masked_cnpj = self.cnpj.mask('11222333444455')
-        self.assertEqual(masked_cnpj, '11.222.333/4444-55')
+        # Given
+        doc = '11222333444455'
+        doc_expected = '11.222.333/4444-55'
+
+        # When
+        masked_cnpj = self.cnpj.mask(doc)
+
+        # Then
+        self.assertEqual(masked_cnpj, doc_expected)
 
     def test_special_case(self):
-        """Verifica os casos especiais de CNPJ."""
+        # Given
         cases = [
             ('00000-000/0000', False),
             ('AAAA0AAAAAAA2AAAAAA', False),
             ('74600269000145', True),
         ]
+
+        # When
         for cnpj, is_valid in cases:
-            self.assertEqual(self.cnpj.validate(cnpj), is_valid)
+            doc_validated = self.cnpj.validate(cnpj)
+
+            # Then
+            self.assertEqual(doc_validated, is_valid)
 
     def test_validate_success(self):
-        """Testar o método validate do CNPJ."""
-        # GIVEN
+        # Given
         doc = '74600269000145'
 
-        # WHEN
-        validate_return = self.cnpj.validate(doc)
+        # When
+        doc_validated = self.cnpj.validate(doc)
 
-        # THEN
-        self.assertTrue(validate_return)
+        # Then
+        self.assertTrue(doc_validated)
 
     def test_validate_wrong_input(self):
-        """Testar o método validate do CNPJ em caso de input errado."""
-        # GIVEN
+        # Given
         doc = '74600269000145_'
 
-        # WHEN
+        # When
         validate_return = self.cnpj.validate(doc)
 
-        # THEN
+        # Then
         self.assertFalse(validate_return)
 
     def test_validate_wrong_length(self):
-        """Testar o método validate do CNPJ em caso de tamanho inválido."""
-        # GIVEN
+        # Given
         doc = '746002690001450'
 
-        # WHEN
+        # When
         validate_return = self.cnpj.validate(doc)
 
-        # THEN
+        # Then
         self.assertFalse(validate_return)
 
     def test_alphanumeric(self):

tests/test_CNS.py

@@ -4,35 +4,47 @@
 
 
 class TestCns(unittest.TestCase):
-    """Testar a classe CNS."""
+    """Testa a classe CNS."""
 
     def setUp(self):
-        """Inicia novo objeto em todo os testes."""
         self.cns = docbr.CNS()
 
-    def test_generate_validate(self):
-        """Verifica os métodos de geração e validação de documento."""
-        # generate_list
-        cnss = self.cns.generate_list(5000) \
-               + self.cns.generate_list(5000, mask=True) \
-               + self.cns.generate_list(5000, mask=True, repeat=True)
-        self.assertIsInstance(cnss, list)
-        self.assertTrue(len(cnss) == 15000)
+    def test_generate_list_with_validate_list(self):
+        # Given
+        number_of_documents = 10
+        number_of_documents_expected = number_of_documents * 2
+
+        # When
+        cnss = self.cns.generate_list(number_of_documents) \
+               + self.cns.generate_list(number_of_documents, mask=True)
+        validated_cnss = self.cns.validate_list(cnss)
 
-        # validate_list
-        cnss_validates = self.cns.validate_list(cnss)
-        self.assertTrue(sum(cnss_validates) == 15000)
+        # Then
+        self.assertIsInstance(cnss, list)
+        self.assertTrue(len(cnss) == number_of_documents_expected)
+        self.assertTrue(sum(validated_cnss) == number_of_documents_expected)
 
     def test_mask(self):
-        """Verifica se o método mask funciona corretamente."""
-        masked_cns = self.cns.mask('111222233334444')
-        self.assertEqual(masked_cns, '111 2222 3333 4444')
+        # Given
+        doc = '111222233334444'
+        doc_expected = '111 2222 3333 4444'
+
+        # When
+        masked_cns = self.cns.mask(doc)
+
+        # Then
+        self.assertEqual(masked_cns, doc_expected)
 
     def test_special_case(self):
-        """ Verifica os casos especiais de CNS """
+        # Given
         cases = [
             ('AAAAAAAAAAA', False),
             ('', False),
         ]
+
+        # When
         for cns, is_valid in cases:
-            self.assertEqual(self.cns.validate(cns), is_valid)
+            doc_validated = self.cns.validate(cns)
+
+            # Then
+            self.assertEqual(doc_validated, is_valid)