Merge pull request #21 from alvarofpp/tests

Tests

tests/__init__.py

@@ -1,21 +1 @@
-import unittest
-
-import tests.test_cpf
-import tests.test_cns
-import tests.test_cnpj
-
-
-def suite():
-    loader = unittest.TestLoader()
-    suite = unittest.TestSuite()
-
-    suite.addTests(loader.loadTestsFromModule(tests.test_cpf))
-    suite.addTests(loader.loadTestsFromModule(tests.test_cns))
-    suite.addTests(loader.loadTestsFromModule(tests.test_cnpj))
-
-    return suite
-
-
-if __name__ == '__main__':
-    runner = unittest.TextTestRunner()
-    runner.run(suite())
+from tests import *

tests/test_all.py

@@ -0,0 +1,21 @@
+import unittest
+# Classes
+import tests.test_cpf
+import tests.test_cns
+import tests.test_cnpj
+
+
+def suite():
+    loader = unittest.TestLoader()
+    test_suite = unittest.TestSuite()
+
+    test_suite.addTests(loader.loadTestsFromModule(tests.test_cpf))
+    test_suite.addTests(loader.loadTestsFromModule(tests.test_cns))
+    test_suite.addTests(loader.loadTestsFromModule(tests.test_cnpj))
+
+    return test_suite
+
+
+if __name__ == '__main__':
+    runner = unittest.TextTestRunner()
+    runner.run(suite())

tests/test_cnpj.py

@@ -3,29 +3,26 @@
 
 
 class TestCnpj(unittest.TestCase):
+    """Testar a classe CNPJ."""
+
     def setUp(self):
-        """ Inicia novo objeto em todo os testes """
+        """Inicia novo objeto em todo os testes."""
         self.cnpj = docbr.CNPJ()
 
-    def test_generate(self):
-        """ Verifica se o método generate """
-        # generate, generate(mask=True)
-        cnpjs = [self.cnpj.generate() for i in range(10000)]\
-                + [self.cnpj.generate(mask=True) for i in range(10000)]
-        self.assertIsInstance(cnpjs, list)
-        self.assertTrue(len(cnpjs) == 20000)
-
-    def test_generate_list(self):
-        """ Verifica se o método generate_list """
+    def test_generate_validate(self):
+        """Verifica os métodos de geração e validação de documento."""
         # generate_list
-        cnpjs = self.cnpj.generate_list(10000)\
-                + self.cnpj.generate_list(10000, True)\
-                + self.cnpj.generate_list(10000, True, True)
+        cnpjs = self.cnpj.generate_list(5000)\
+                + self.cnpj.generate_list(5000, mask=True)\
+                + self.cnpj.generate_list(5000, mask=True, repeat=True)
         self.assertIsInstance(cnpjs, list)
-        self.assertTrue(len(cnpjs) == 30000)
+        self.assertTrue(len(cnpjs) == 15000)
+
+        # validate_list
+        cnpjs_validates = self.cnpj.validate_list(cnpjs)
+        self.assertTrue(sum(cnpjs_validates) == 15000)
 
-    def test_validate(self):
-        """ Verifica se o método validate """
-        # validate
-        for cnpj in self.cnpj.generate_list(10000):
-            self.assertTrue(self.cnpj.validate(cnpj))
+    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')

tests/test_cns.py

@@ -3,29 +3,26 @@
 
 
 class TestCns(unittest.TestCase):
+    """Testar a classe CNS."""
+
     def setUp(self):
-        """ Inicia novo objeto em todo os testes """
+        """Inicia novo objeto em todo os testes."""
         self.cns = docbr.CNS()
 
-    def test_generate(self):
-        """ Verifica se o método generate """
-        # generate, generate(mask=True)
-        cnss = [self.cns.generate() for i in range(10000)]\
-                + [self.cns.generate(mask=True) for i in range(10000)]
-        self.assertIsInstance(cnss, list)
-        self.assertTrue(len(cnss) == 20000)
-
-    def test_generate_list(self):
-        """ Verifica se o método generate_list """
+    def test_generate_validate(self):
+        """Verifica os métodos de geração e validação de documento."""
         # generate_list
-        cnss = self.cns.generate_list(10000)\
-                + self.cns.generate_list(10000, True)\
-                + self.cns.generate_list(10000, True, True)
+        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) == 30000)
+        self.assertTrue(len(cnss) == 15000)
+
+        # validate_list
+        cnss_validates = self.cns.validate_list(cnss)
+        self.assertTrue(sum(cnss_validates) == 15000)
 
-    def test_validate(self):
-        """ Verifica se o método validate """
-        # validate
-        for cns in self.cns.generate_list(10000):
-            self.assertTrue(self.cns.validate(cns))
+    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')

tests/test_cpf.py

@@ -3,32 +3,29 @@
 
 
 class TestCpf(unittest.TestCase):
+    """Testar a classe CPF."""
+
     def setUp(self):
-        """ Inicia novo objeto em todo os testes """
+        """Inicia novo objeto em todo os testes."""
         self.cpf = docbr.CPF()
 
-    def test_generate(self):
-        """ Verifica se o método generate """
-        # generate, generate(mask=True)
-        cpfs = [self.cpf.generate() for i in range(10000)]\
-                + [self.cpf.generate(mask=True) for i in range(10000)]
-        self.assertIsInstance(cpfs, list)
-        self.assertTrue(len(cpfs) == 20000)
-
-    def test_generate_list(self):
-        """ Verifica se o método generate_list """
+    def test_generate_validate(self):
+        """Verifica os métodos de geração e validação de documento."""
         # generate_list
-        cpfs = self.cpf.generate_list(10000)\
-                + self.cpf.generate_list(10000, True)\
-                + self.cpf.generate_list(10000, True, True)
+        cpfs = self.cpf.generate_list(5000)\
+                + self.cpf.generate_list(5000, mask=True)\
+                + self.cpf.generate_list(5000, mask=True, repeat=True)
         self.assertIsInstance(cpfs, list)
-        self.assertTrue(len(cpfs) == 30000)
+        self.assertTrue(len(cpfs) == 15000)
 
-    def test_validate(self):
-        """ Verifica se o método validate """
-        # validate
-        for cpf in self.cpf.generate_list(10000):
-            self.assertTrue(self.cpf.validate(cpf))
+        # validate_list
+        cpfs_validates = self.cpf.validate_list(cpfs)
+        self.assertTrue(sum(cpfs_validates) == 15000)
+
+    def test_mask(self):
+        """Verifica se o método mask funciona corretamente."""
+        masked_cpf = self.cpf.mask('11122233344')
+        self.assertEqual(masked_cpf, '111.222.333-44')
 
     def test_special_case(self):
         """ Verifica os casos especiais de CPF """